彩笺的信息资源网

useful website2

Wed, 30 Oct 2024 00:00:00 GMT

免费可商用图标库

remixicon.com

经典绝版游戏

原文：https://skywind.me/blog/archives/2863 韦神收集并开源的经典绝版游戏合集

使用AI生成美观卡片&AI算卦

Wed, 23 Oct 2024 00:00:00 GMT

所有prompt记录在：https://github.com/netlogs/prompt

以下为部分展示

国家/城市分布图

::image{src="/images/prompt/city.webp" alt="国家/城市分布图"}

命理大师

::image{src="/images/prompt/minglidashi.webp" alt="命理大师"}

AI算卦图

::image{src="/images/prompt/8guaImage.png" alt="AI算卦"}

青蛙的一生

::image{src="/images/prompt/frog.webp" alt="青蛙的一生"}

Google AdSense 国内提现教程：工商银行收款攻略

Sun, 13 Oct 2024 00:00:00 GMT

Google AdSense 国内提现教程：工商银行收款攻略 https://uuzi.net/google-adsense-withdrawal-guide-china-icbc-payment-strategy/

有趣的网站1

Sat, 12 Oct 2024 00:00:00 GMT

免费在线证件照制作

https://photo4you.win/

文字转图片

开源的、纯前端的文字转图片网站

https://oneimgai.com/

https://github.com/byodian/oneimg（github地址

匿名聊天

开源的浏览器插件，基于 WebRTC，为同一个页面的访问者建立去中心化、无服务器的匿名聊天，可用于任意网站。

https://chromewebstore.google.com/detail/webchat/cpaedhbidlpnbdfegakhiamfpndhjpgf

NotebookLM

https://notebooklm.google/

谷歌推出的一个新服务，可以将一篇文章转成学习笔记或者播客。

也就是说，你上传文章后，它可以将文章转成一个英文的广播节目，内容是两个 AI 主持人一问一答介绍这篇文章，参见官方的介绍。它甚至能将 Youtube 的视频转成播客。

文本转语音

跨平台的文本转语音的桌面工具，支持调用多个 API，免费使用

https://github.com/ElmTran/praises

Hack news|黑客新闻搜索引擎

第三方的“黑客新闻”搜索引擎，使用体验很不错。

https://hn.trieve.ai/

中文Hack news

这个网站实时给“黑客新闻”每个链接生成摘要。

https://zeli.app/

esim-moldova保号流程

Fri, 11 Oct 2024 00:00:00 GMT

注册账号

打开My Moldtelecom的Web端登录界面。（也可以在Google Play Store或者Apple Store中下载My Moldtelecom的APP。）

首次登录账号需要进行注册。点击“Sign up”按钮。

::image{src="/images/moldova/moldtelecom-08.jpg" alt="摩尔多瓦esim"}

点击“Phone”输入自己的手机号码，接下来点击“Next”按钮，此时系统会向我们的手机号发送一条短信验证码。

::image{src="/images/moldova/moldtelecom-09.jpg" alt="摩尔多瓦esim"}

在“Verification code”一栏填入收到的短信验证码，在“Password”和“Re-enter the password”一栏输入自己设置的登录密码，然后点击“Sign up”按钮。此时已完成注册。

::image{src="/images/moldova/moldtelecom-10.jpg" alt="摩尔多瓦esim"}

再次回到My Moldtelecom的Web端登录界面，输入用户名和密码，然后点击“Login”按钮。其中用户名是我们的号码。

查看号码有效期

登陆后，界面如下图所示。

::image{src="/images/moldova/moldtelecom-11.jpg" alt="摩尔多瓦esim"}

页面的中心区域显示的就是当前号码的信息。Status表示号码当前的状态，Active till表示号码的有效期，Grace period表示号码的宽限期。

充值

点击页面左下角的“Pay for services”按钮。

在页面左上角勾选需要充值的号码，输入充值的金额，点击“Pay with credit card”按钮，进入支付界面。

::image{src="/images/moldova/moldtelecom-12.jpg" alt="摩尔多瓦esim"}

在支付界面依次输入银行卡上的持卡人姓名、卡号、有效期、CVV码，然后点击底部的“PAY”按钮。支持Visa、Master、Google Pay、Apply Pay。

支付成功后，号码信息会相应的更新。经测试，号码的有效期、宽限期不会累积，只是从充值当日重新顺延。

纯净无广告galgame资源网站

Fri, 11 Oct 2024 00:00:00 GMT

无门槛无广告免登录最牛galgame网站

好用网站、应用第三期

Fri, 13 Sep 2024 00:00:00 GMT

在线音频处理

之前分离歌曲人声，找到的网站，免费使用，无广告

::image{src="/images/apporweb3/0.png" alt="在线音频处理"}

https://100audio.com/sound/100audio_editor/

SMS-Activate线接受短信的虚拟号码服务

使用SMS-Activate的虚拟号码来在线接受短信。可以在600个多服务注册的一次性号码。

::image{src="/images/apporweb3/1.png" alt="SMS-Activate"}

https://sms-activate.io/cn

在线工具箱

在线工具,开发人员工具,代码格式化、压缩、加密、解密,下载链接转换,json格式化,正则测试工具,favicon在线制作,字帖工具,中文简繁体转换,迅雷下载链接转换,进制转换,二维码,照片压缩,pdf合并

::image{src="/images/apporweb3/2.png" alt="在线工具箱"}

https://tool.lu/

免费的 Notion 风格头像在线制作器

Notion头像是一种个性化的头像，设计风格与Notion（一款流行的笔记和组织工具平台）相匹配。这些头像可以用作Notion内的个人头像，或用于其他社交媒体平台，以保持视觉上的一致性和个人品牌形象。

风格如何，是不是很文艺~

::image{src="/images/apporweb3/3.png" alt="Notion风格头像在线制作器"}

https://www.notionavatarmaker.com/zh

如果没有查找到想要的资源，欢迎去公众号给我留言~

web3入门1 | 人话说比特币和区块链

Wed, 11 Sep 2024 00:00:00 GMT

由比特币区块链构成的去中心化的电子记账系统，实现了去中心化的功能，如何实现，且看下面：

1.比特币和区块链详解

比特币

数字货币，基于区块链。

区块链

中本聪提出了一个概念：去中心化的电子记账系统

去中心化：每个人的账本公开

假设A，B，C，D四个人之间互相交易，每两个人之间的交易记录都会被其他人记录到。

把n(4k左右)个交易记录合成的账单称之为区块

账单多了之后，区块与区块链接起来，成为区块链

这种格局就形成了所谓的：电子记账

比特币从何而来？

记账：中本聪规定每10分钟打一个新的区块包，打包成功的人会获得手续费和比特币奖励，比特币奖励最初为50个比特币，每四年折半。

怎么界定成功打包的这个人？

工作量证明

中本聪规定，大约每10分钟打一个包。

每一个参与打包的都要做一个很难的数学题，谁先做出来谁就有权利打包（大白话一个一个数去尝试，尝试出来你就有权利）这也就是：挖矿。

挖矿的具体原理

背景了解：

密码学有个东西叫做hash函数，他的特点为：

一个任意长度的字符串可以通过运算转换为一个叫做摘要的东西。

正向运算转换很容易，反向很难

举例： hash运算有个很著名的算法SHA256

字符串：SHA256("awegagasdf") = "0100110111"(一共256位的0和1)

挖矿原理：

每个区块除了具体信息还包含一个头部。

假设区块链此时长度为5，此时有n个人要准备打新包，每个人都有账单

每个人手里都有一个字符串，大致组成为：

字符串 = 区块链最后一个块的头部信息+手里账单信息+时间戳+随机数

每个人对此字符串做两次hash运算

hash=sha256(sha256(字符串))

最后得到一个256位包含0和1的数。

什么样的人可以获得最后打包权利呢？

**答：**谁计算出来的hash的前m位都为0，那么谁就获得打包权利。

如何才能计算出来符合要求的hash呢？通过不断改变字符串里面的随机数进行尝试。

如何保证每10分钟打包一个块呢？

**答：**根据全世界的算力，调整m的难度。也就是说随着挖矿的人越来越多，m会越来越长。

2. 比特币交易

如何保证交易真实？

在中心化交易的世界里，由银行和背后的国家来确保交易双方的身份。比如人脸、签名、指纹

在去中心化的世界里，通过电子签名来实现。

电子签名

比特币用户在注册的时候，会生成一个随机数

随机数--> 私钥 --> 公钥 --> 地址

私钥必须保存好，它代表了你的资产，要保管好。

公钥和地址都是公开的。

如果你想别人给你钱，你把地址给他就可以了。

如果你要给别人钱，你把自己的地址和公钥给他。

特点：公钥反算不出来私钥。

**使用：**私钥可以对一串字符加密，公钥可以将私钥加密的数据解密。（非对称加密）

举例：A要付给B 10个比特币

A先写一条记录：A---(10BTC)---> B
A对记录进行hash运算出来摘要
A使用私钥对摘要加密，产生一个密码
对全网广播，告诉别人我给了B10个比特币，同时广播公钥和密码
别人拿到广播之后，会对A这一条记录先hash运算，这个结果和A自己算出来的摘要是一样的。
使用A的公钥和密码进行解密，将上一步算出来的摘要和解密的摘要进行对比。
比对结果一致，代表你的电子签名ok。

交易隐患

存在两个问题：

A要给10个BTC给B，那怎么检查A有没有10个BTC？
假设A有10个BTC，如果A同时说我分别给B和C10个BTC，如何避免这种现象？

我们知道区块链的概念，我们每个人都知道前面的所有区块的信息。当A说要支付10个BTC给B时，可以从前面的区块链检查，A所有的比特币交易记录，从而得知A的余额。

如果你余额足够，那么你广播的这条：你要支付B10个BTC的信息就会被打包，反之，大家会拒绝你这条消息。

第二个问题：

A同时广播：

消息1：A---(10BTC)---> B

消息2：A---(10BTC)---> C

当有人接收到第一条消息之后，会检查A的余额，不够的话会自然的拒绝第二条消息，同理其他先接收到第二条消息的也一样。

此时会有两部分人，分别将消息1和消息2打包到块里面，但是此时还没确认，大家都在打包挖矿做工作量证明。

假设一个幸运儿挖到了矿，那么他成功打包了一个新的区块，这个区块包含了消息1。

然后他将新区块链接到了最大的区块链上（公链）

此时在消息2上挖矿的人一看，上面有新块被打出来了，那么所以人都会放弃自己的块，站队到消息1的那个块。反之同理。

总结：我们接收到别人对我们的付款时，必须等到付款消息被打包，才是真的到账了。

最长链原则

是存在那么一种可能，同一时刻有两个幸运儿同时挖矿打包成功，此时会造成公链会分叉。

有两拨人会继续基于自己的分叉继续挖矿，总有一个时刻，某分叉：分叉1上会优先打出来一个包，分叉1为最长的区块链。此时分叉2的人会过来站队，放弃分叉2，区块链又回归到了一条链的状态。

下一篇：以太网那些事

web3入门2 | 人话说以太坊

Wed, 11 Sep 2024 00:00:00 GMT

公链之王以太坊

上一期我们介绍了去中心化、区块链，比特币；那为什么还有以太坊呢？

它是什么？解决了什么问题？

以太坊解决了什么问题？

先来看看以太坊对自己的定义：以太坊是新一代的智能合约和去中心化应用

看不懂没关系，先不看。

回顾比特币，我们可以发现他的去中心化仅仅体现在了交易上，有了比特币，我们每个人都拥有着对自己的资金的绝对掌握权，不用考虑现实中国际边界等一系列问题。

但也仅限于此了。比特币设计之初我们也能看到就只是一个电子现金交易的解决方案：去中心化的电子记账系统

其他的去中心化需求，是不能很好的得到支持的，此时以太坊应然而生。

以太坊提出来一种设想，是不是可以提供一个平台来创建这些去中心化的应用。

解决方案

1.做标准、统一语言、简化协议

基于区块链技术，以太坊提出了一套全球通用，简单易用的可编程区块链语言：Solidity
在协议上你想发行自己的代币，那么就要使用ERC-20协议标准。该协议标准允许开发者构建可以和其他应用或者服务交互的代币应用程序。

ERC-20

一个同质化代币的标准，换句话说，它们具有一种属性，使得每个代币都与另一个代币（在类型和价值上）完全相同。例如，一个 ERC-20 代币就像以太币一样，意味着一个代币会并永远会与其他代币一样。

在以太坊的官方文档里，有着非常详细并且清晰的解释文档链接

2. 智能合约

Solidity这个编程语言主要用来写智能合约，智能合约从smartcontract翻译而来，直白翻译可以理解为：不可更改的电子合同

在现实世界，我们和外界的交互，很多都需要签合同来确保双方的规范行为。例如租房、找工作，都需要签合同，只不过合同依靠国家系统来确保其发挥作用。

而智能合约就是比特币的分布式记账，不可被篡改的思路的一个很好的体现。它就像合同代码化、程序化并且放在了区块链上确保其不被更改。智能合约一旦运行就不可更改。

举个栗子：美元兑换人民币

交易逻辑是A的账户减去一定量的美元，同时B的账户增加一定量的人民币

智能合约就是把此逻辑使用代码实现并切放在了公链上，大家都能看到其具体的实现，并且无法篡改。

其中的隐患

当时基于智能合约的特点，人们发现去中心化的组织也完全可以利用智能合约来实现。

组织或者社区的本质是一群人聚到一起，按照特定的规则形式，而这个规则完全可以用智能合约实现。

当时最初的一个组织，The DAO(decentralized autonomous organization)，其使用的叫DAO币。

发生了这么一个事：DAO众筹了总价值约1.5亿美元的资金，如此大的众筹项目被黑客盯上了，并且还真给黑客找到了合约中的漏洞，盗走了约1/3的总资金。

这就相当于一个合同在设计之初，遗漏了某些特殊情况，留下了漏洞，被钻了空子。

按照现实来理解：彩票规则出现了漏洞，结果奖池被人为的掏空。

此时社区经过讨论，选择基于被盗之前的公链硬分叉出去，强行改变规则按照新叉来走。

可想而知，争议也是巨大的。

一部分人任务这违反了去中心化的精神，而另一部分人认为社区需要正义的力量。

由此次事件，也衍生出了两种以太坊代币。

一种是ETC，代表了去中心化不可篡改的精神，账本形成了就是不可更改。

另一种就是今天我们最常用的ETH。也就是硬分叉之后的新链。

而比特币，到目前为止可以说是一个完全去中心化的网络，中本聪创建比特币网络之后，就消失了，区块链按照最初的规则就这么运行了10多年。

奖励机制

最开始以太坊和比特币一样，都是按照工作量证明POW（Proof of work）来进行

后来以太坊更改激励规则成了POS（Proof of stack）。简单来说就是你持有该网络的货币数量越多，参与记账可获得的奖励就越多。

web3入门3 | Solidity简明教程

Wed, 11 Sep 2024 00:00:00 GMT

Solidity简明教程

本教程适用于有语言基础，速查或者快速入门。

版权许可标识

// SPDX-License-Identifier: MIT

一般放在文件开头

更多内容请查看https://learnblockchain.cn/docs/solidity/layout-of-source-files.html

版本

pragma solidity ^0.5.2;

含义是既不允许低于 0.5.2 版本的编译器编译，也不允许高于（包含） 0.6.0 版本的编译器编译（第二个条件因使用 ^ 被添加）。

pragma solidity >=0.6.12 <0.9.0;

变量

默认值

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

contract DefaultValues {
    bool public b; //false
    uint public u; //0
    int public i; //0
    address public a; //0x0000000(一共40个0,20位16进制数字)
    bytes32 public b32; //0x00000 一共64个0,32位

}

常量

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

contract Constants {
    address public constant MY_ADDRESS = 0x2E35C375782713b7feedEd99B18C2F2728B2566D;
    uint public constant MY_UINT = 123;
}


contract Var {
    address public myaddr = 0x2E35C375782713b7feedEd99B18C2F2728B2566D;
}

constant定义常量

常量和变量消耗的gas不一样，deploy之后点击MY_ADDRESS可以查看gas费用是373

execution cost	373 gas (Cost only applies when called by a contract)

下面这是Var合约内读取myaddr消耗的gas

execution cost	2483 gas (Cost only applies when called by a contract)

结构控制

判断

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

contract IfElse {
    function example(uint x) external pure returns (uint) {
        if (x < 10) {
            return 1;
        } else if ( x < 20) {
            return 2;
        } else {
            return 3;
        }
    }
    function ternary(uint x) external pure returns (uint) {
        return x < 10 ? 1 : 2;
    }
}

循环

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

contract ForAndWhile {
    function loops() external pure {
        for (uint i = 0; i < 10; ++i) {
            //code
           if (i == 2)  continue;
            if (i == 4) {
                break;
            }
        }
        int b = 3;
        while(b > 0) {
            --b;
        }
    }
}

和C语言一样，同时要注意控制循环次数，太多的循环会导致gas费用的高昂

Error

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

// require, revert, assert
// - gas refund, state updates are reverted
// 8.0 version 更新了，custom error, save gas
contract Error {
    function testRequire(uint _i) public pure {
        require(_i <= 10, "i > 10");
        //code
    }
    function testRevert(uint _i) public pure {
        if(_i > 10) {
            revert("i > 10");
        }
        //code
    }
    uint public num = 123;
    function testAssert() public view {
        assert(num == 123);
    }

    function foo(uint _i) public {
        num += 1;
        require(_i < 10); //如果i不符合条件，前面+1的num会被回滚，状态不会被更改，gas退还
    }

    
    function testCustomError1(uint _i) public pure {
        require(_i <= 10, "very long error message xxxxxxxxxxxxxxx");//使用require时，如果error信息很长，会消耗很多gas
    }

    error MyError();

    function testCustomError2(uint _i) public pure {
        if (_i > 10) revert MyError(); //通过这种方式触发自定义报错
    }
    //同时可以：
    error MyError2(address caller, uint i);
    function testCustomError3(uint _i) public view {
        if (_i > 10) revert MyError2(msg.sender, _i); //通过这种方式触发自定义报错
    }
}

函数

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

contract Counter {
    uint public cnt;
    function inc() external {
        cnt += 1;
    }

    function dec() external {
        cnt -= 1;
    }
}

external：外部可视，意思是在合约内部的其他函数不可以调用，只能被外部读取

public：公开可视，内部外部都可以调用

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

contract FUnctionOutputs {
    function returnMany() public pure returns (uint, bool) {
        return (1, true);
    }
    function returnManyWithname() public pure returns (uint x, bool b) {
        return (1, true);
    }
    //隐式赋值返回
    function assigned() public pure returns (uint x, bool b) {
        x = 1; 
        b = true;
    }

    //合约内调用
    function otherfunc() public pure {
        (uint a, bool b) = returnMany();
        (, bool _b) = returnManyWithname();
    }
}

函数修改器

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

contract FunctionModifier {
    bool public paused;
    uint public cnt;

    function setPasuse(bool _paused) external {
        paused = _paused;
    }

    function inc() external {
        require(!paused, "paused");
        cnt += 1;
    }
    function dec() external {
        require(!paused, "paused");
        cnt -= 1;
    }
    //当我们期望合约暂停时cnt不被修改，我们可以在修改的func中添加require，函数修改器支持更强大的操作，
    //有点类似于C语言中，把暂停的判断提炼到一个判断函数内，然后在修改的函数都提前调用一下判断函数
    //写法：
    modifier whenNotPaused() {
        require(!paused, "paused");
        _; //此处代表，使用此修改器的函数的其他的代码在哪里运行
    }

    function new_incOr_dec() external whenNotPaused {
        //cnt += 1; or cnt -= 1;
    }


    //带参数的函数修改器

    modifier cap(uint _x) {
        require(_x < 100, "x >= 100");
        _;
    }
    function incBy(uint _x) external whenNotPaused cap(_x) {
        cnt += _x;
    }

    //sanddwich写法
    //下面相当于把foo中对cnt的一部分操作提到了修改器中
    //cnt 先执行+=10，再返回foo执行+=1，再返回sandwich执行*=2
    modifier sandwich() {
        cnt += 10;
        _;
        cnt *= 2;
    }

    function foo() external sandwich {
        cnt += 1;
    }
}

构造函数

合约部署时被调用一次，之后再也不能被调用

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

contract Constructor {
    address public owner;
    uint public x;

    constructor(uint _x) {
        owner = msg.sender;
        x = _x;
    }
    //通过传参赋予x值，ctrl+s编译好之后，部署时，Deploy旁边会多一个输入框，代表构造函数的参数列表
}

数组

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

contract Array {
    uint[] public nums = [1, 2, 3];
    uint[10] public numsFixed= [4, 5, 6];

    function examples() external {
        nums.push(4); //[1, 2, 3, 4]; 适用于不定长数组
        nums[1] = 9; //下标，和C语言一样[1, 9, 3, 4]
        delete nums[1]; //[1, 0, 3, 4] ！不能减少数组长度
        nums.pop(); //[1, 0, 3] 类似于stl中的stack，减少了数组长度
        uint len = nums.length; //长度

        //create array in memory
        uint[] memory arr = new uint[](5);
        //在内存中的不允许pop、push
    }

    function returnArray() external view  returns (uint[] memory) {
        return nums;


    }
}

映射

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

contract Array {
    mapping(address => uint) public balances;
    mapping(address => mapping(address => bool)) public isFriend;

    function examples() external {
        balances[msg.sender] = 123;
        uint bal = balances[msg.sender];
        uint bal2 = balances[address(1)]; // 0
        balances[msg.sender] += 456;

        delete balances[msg.sender]; //0

        isFriend[msg.sender][address(this)] = true;

    }
}

结构体

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

//结合数组和mapping
contract Structs {
    struct Car {
        string model;
        uint year;
    }

    Car public car;
    Car[] public cars;

    mapping(address => Car[]) public carsByOwner;

    function examples() external {
        Car memory toyota = Car("Toyota", 1999);
        Car memory lambo = Car({year: 111, model: "Lamborghini"});
        Car memory zero;
        zero.model = "aaaa";
        zero.year = 1993;

        cars.push(zero);
        cars.push(toyota);
        cars.push(lambo);

        cars.push(Car("Tesla", 1991));

        Car memory temp = cars[0];
        Car storage real = cars[0];
        real.year = 0; //storage带有指针效果
        delete real.year; //恢复cars[0]的成员year的默认值
        delete cars[1]; //默认值全部恢复
    }
}

枚举

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

//结合数组和mapping
contract Enums {
    enum Status {
        None,
        Pending,
        Shipped,
        Completed,
        Rejected,
        Canceled
    }

    Status public status;

    struct Order {
        address buyer;
        Status status;
    }

    Order[] public orders;

    function get() external view returns (Status) {
        return status;
    }

    function set(Status _status) external {
        status = _status;
    }

    function ship() external {
        status = Status.Shipped;
    }

    function reset() external {
        delete status; //枚举类型的默认值是第一个字段，本例为"None"
    }
}

小结

管理员合约

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

contract Owner {
    address public owner;

    constructor() {
        owner = msg.sender;
    }

    modifier onlyOwner() {
        require(owner == msg.sender, "no owner");
        _;
    }

    function setOwner(address _newowner) external onlyOwner {
        require(_newowner != address(0), "no 0 address");
        owner = _newowner;
    }

    function ownerUse() external onlyOwner {
        //code
    }

    function anyoneUse() external {
        //code
    }
}

存储位置

memory 内存的存储类型，局部变量，生命周期随着作用域结束而结束

storage 状态变量的存储类型，有点像引用或者指针

calldata 只能用在参数中，如果使用calldata，会节约gas

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;

contract DataLocations {
    struct Mystruct {
        uint foo;
        string text;
    }

    mapping(address => Mystruct) public mys;

    function examples(uint[] calldata y, string calldata s) external returns (uint[] memory) {
        mys[msg.sender] = Mystruct({foo: 123, text: "bar"});
         Mystruct storage p = mys[msg.sender]; //此处也可以直接mys[msg.sender].text进行修改，当修改量少时消耗较少的gas，修改项多时使用storage
         p.text = "new_text"; //mys[msg.sender].text is: new_text

         Mystruct memory readonly = mys[msg.sender];
         readonly.foo = 444; //but ..mys[msg.sender].foo is: 123

         _internal(y); 
         //1. 如果_internal函数的参数列表中的y是memory类型，那么这里调用的时候会进行一次拷贝，消耗gas
         //如果使用calldata那么可以直接传递过去，不会发生拷贝

         uint[] memory memArr = new uint[](5);
         memArr[0] = 1;
         return memArr;
    }

    function _internal(uint[] calldata y) private {
        uint x = y[0];
    }

}

事件

记录当前contract状态的方法，不会记录在状态变量之中，而是体现在区块链浏览器上或者交易记录中的log

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;

contract Event {
    event Log(string message, uint val);
    event IndexLog(address indexed sender, uint val, uint a, uint b); //添加indexed 链外可以搜索查询

    

    function examples() external {
        emit Log("hahaha", 1234);
        emit IndexLog(msg.sender, 22, 22, 22); //在链外通过工具可以查询该地址的一些事件
        
    }

    event Message(address indexed _from, address indexed _to, string message);

    function sendMessage(address _to, string calldata message) external {
        emit Message(msg.sender, _to, message);
    }
}

继承那些事

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;

contract A {
    function foo() public pure virtual returns (string memory) {
        return "A";
    }
    function bar() public pure virtual returns (string memory) {
        return "A";
    }
    function baz() public pure returns (string memory) {
        return "A";
    }
}

contract B is A { //继承写法
    function foo() public pure override returns (string memory) {
        return "B";
    }
    function bar() public pure virtual override returns (string memory) {
        return "A";
    }
}

contract C is B {
    function bar() public pure override returns (string memory) {
        return "C";
    }
}

多线继承

优先写比较基类的继承关系，

X基类，Y is X
Z is X, Y
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;

contract X {
    function foo() public pure virtual returns (string memory) {
        return "X";
    }
    function bar() public pure virtual returns (string memory) {
        return "X";
    }
    function x() public pure returns (string memory) {
        return "X";
    }
}

contract Y is X { //继承写法
    function foo() public pure virtual override returns (string memory) {
        return "Y";
    }
    function bar() public pure virtual override returns (string memory) {
        return "Y";
    }
    function y() public pure returns (string memory) {
        return "Y";
    }
}

contract Z is X, Y {
    function foo() public pure override(X, Y) returns (string memory) {
        return "Z";
    }

    function bar() public pure override(X, Y) returns (string memory) {
        return "Z";
    }
}

调用父级合约的构造函数

contract X {
    function foo() public pure virtual returns (string memory) {
        return "X";
    }
    function bar() public pure virtual returns (string memory) {
        return "X";
    }
    function x() public pure returns (string memory) {
        return "X";
    }
}

contract Y is X {
	X.foo(); //1
	super.foo(); //2 多重继承时，父类的func都会被执行
}

可视范围

private 内部可见
internal 内部inside和继承child范围可见
public 内部inside和外部可见
external 仅仅外部可见

不可变常量

关键词：immutable

第一次定义后，就不可被改变

一般用于你不知道其初始化，但是又是常量的情况。第一次赋值后变为常量。

接受ETH

关键词：payable

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.2;

contract Payable {
    address payable public owner; //可发送ETH主币

    constructor() {
        owner = payable(msg.sender); //使用时要给带有payable属性
    }

    function deposit() external payable { //函数可接受ETH主币的传入

    }

    function getBalance() external view returns (uint) {
        return address(this).balance;
    }
}

回退函数

当你调用合约中不存在的函数时，或者向合约发送主币的时候，都会调用回退函数

当你期望发送主币的时候触发fallback，那么你需要给fallback方法加上payable属性，

solidity8.0以上，新增receive用来只接受主币

触发逻辑：*当合约收到主币时，判断是否调用了数据，也就是msg.data是否为空，如果没有调用数据，执行*fallback。如果为空，判断receive是否存在，存在调用receive**，调用receive，如果不为空，不存在调用fallback

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.2;

contract Fallback {
    event Log(string func, address sender, uint value, bytes data);
    fallback() external payable {
        emit Log("fallback", msg.sender, msg.value, msg.data);
    }
    receive() external payable {
        emit Log("receive", msg.sender, msg.value, "");
     }
}

发送ETH

transfer 消耗2300gas，gas耗费完或者其他异常情况，revert

send 消耗2300gas，返回bool值

call 会把剩余的gas都发送过去

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.2;
//transfer  2300gas revert
//send    2300 gas, return bool
//call   all gas, returns bool and data
contract SendETH {
    constructor() payable {

    }
    receive() external payable {

    }

    //三种发送ETH主币的方法
    function Sendbytransfer(address payable _to) external payable {
        _to.transfer(123);
    }
    function Sendbysend(address payable _to) external payable {
        bool sent = _to.send(123);
        require(sent, "send failed");
    }
    function Sendbycall(address payable _to) external payable returns (bytes memory) {
        (bool success, bytes memory data) = _to.call{value: 123}("");
        require(success, "send failed");
        return data;
    }
    
}

//接受ETH的合约，即上面的发送合约发送ETH到该地址

contract Ethreceive {
    event Log(uint amount, uint gas);

    receive() external payable {
        emit Log(msg.value, gasleft());
    }
}

小结：钱包合约

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.2;

contract EthWallet {
    address payable public owner;

    constructor() payable {
        owner = payable(msg.sender);
    }

    receive() external payable { }

    function withdraw(uint _amount) external {
        require(msg.sender == owner, "no owner");

        owner.transfer(_amount); //两种效果一样，但是msg.sender在内存，节约gas
        //payable(msg.sender).transfer(_amount);
    }
    function getBalance() external view returns (uint) {
        return address(this).balance;
    }
    function getOwnBalance() external view returns (uint) {
        return msg.sender.balance;
    }
}

调用其他合约

区分两种不同的调用方式，以及可以在调用的时候发送主币

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.2;

contract CallTest {
    function setOtherContract_X(address _test, uint _x) external {
        Test(_test).setX(_x);
    }
    
    function getOtherContract_X(Test _test) external view returns (uint) {
        return _test.getX(); //直接将另一个合约名字作为类型传参，然后调用也可
    }

    function setOtherContract_XandETH(address _test, uint _x) external payable {
        Test(_test).setXandReceiveETH{value: msg.value}(_x);
    }

    function getOtherContract_XandETH(Test _test) external view returns (uint, uint) {
        return _test.getXandETH(); 
    }
    

}
contract Test {
    uint public x;
    uint public value;

    function setX(uint _x) external {
        x = _x;
    }
    function getX() external view returns (uint) {
        return x;
    }

    function setXandReceiveETH(uint _x) external payable {
        x = _x;
        value = msg.value;
    }
    function getXandETH() external view returns (uint, uint) {
        return (x, value);
    }

}

接口合约

当我们不知道另一个合约的源码，或者另一个合约源码很长，可以通过接口方法来调用

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.2;

//此为外部其他的合约，我们不知道其源码，但是我们知道它实现了Icounter接口
contract Count {
    uint public count;

    function inc() external {
        count += 1;
    }
    function dec() external {
        count -= 1;
    }

}

interface Icounter {
    function count() external view returns (uint); //外部合约Count中有count变量，所以这也可以是一个接口
    function inc() external;
}

contract CallInterface {
    uint public count;
    function example(address _cnt) external {
        Icounter(_cnt).inc();
        count = Icounter(_cnt).count();
    }
}

call调用合约

在call合约中使用：

_test.call{value: 111}(abi.encodeWithSignature());来调用另一个合约的函数，依靠abi.encodeWithSignature来实现。

其中value: 111表示在调用是发送主币，也可以带有gasvalue: 111, gas:5000但是要确保gas够用。

当Test合约的fallback不存在时，使用call调用不存在的函数时，即下文callnoexist会失败，原理见：回退函数

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.2;

contract Test {
    string public message;
    uint public x;

    event Log(string message);

    
    fallback() external payable {
        emit Log("fallback was called");
    }
    

    function foo(string memory _message, uint _x) external payable returns (bool, uint) {
        message = _message;
        x = _x;
        return (true, 11);
    }
}

contract Call {
    bytes public data;
    function callFoo(address _test) external payable {
        (bool success, bytes memory _data) = _test.call{value: 111}(abi.encodeWithSignature(
            "foo(string, uint256", "call foo", 123
        ));
        require(success, "call failed");
        data = _data;
    }

    function callnoexist(address  _test) external {
        (bool success, ) = _test.call(abi.encodeWithSignature("noexist"));
        require(success, "call failed");
    }
}

委托调用

传统调用：

A call B, send 100wei
B call C, send 50wei

在C的视角
msg.sender = B;
msg.value = 50;
可能发生的状态变量也是在C上，ETH主币也会留在C中

而委托调用：delegatecall

A call B, send 100wei
B delegatecall C

此时，在C的视角
msg.sender = A;
msg.value = 100;
100个ETH主币保存在B，状态也是B中的状态变量发生改变。

人话： 合约X委托调用合约Y的函数，相当于使用了Y的函数作用于自身，在下面的函数中，DelegateCall委托调用了Test中的setVars方法，作用于DelegateCall合约自身。发生改变的也是DelegateCall的状态变量。

tip：两个合约的状态变量等布局要保持一致，不然会发生奇怪的错误，本质上像是内存布局的调用，假设DelegateCall的状态变量和Test的前面的状态变量一样，Test后面新增几个新的状态变量，就不会发生错误。

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.2;

contract Test {
    uint public num;
    address public sender;
    uint public value;

    function setVars(uint _num) external payable {
        num = _num*2;
        sender = msg.sender;
        value = msg.value;
    }
}

contract DelegateCall {
    uint public num;
    address public sender;
    uint public value;

    function setVars(address _test, uint _num) external payable {
        //_test.delegatecall (
        //    abi.encodeWithSignature("setVars(uint256)", _num)
        //);

        //两种方法效果一样

        (bool success, bytes memory _data) = _test.delegatecall (
            abi.encodeWithSelector(Test.setVars.selector, _num)
        );
        require(success, "delegatecall failed");
    }


}

工厂合约

可以使用一个合约，创建另一个合约，同时也是可以添加payable方法，使用value来给合约发送ETH主币。

在ide测试使用的时候，deploy工厂之后，生成了一个account地址，可以通过deploy按钮下面的At address来直接生成对应的Account合约，然后就可以查看其内容了。

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.2;

contract Account {
    address public bank;
    address public owner;

    constructor(address _owner) payable {
        bank = msg.sender;
        owner = _owner;
    }
}

contract AccountFactory {
    Account[] public accounts;
    function createAccount(address _owner) external payable {
        Account account = new Account{value: 123}(_owner);
        accounts.push(account);
    }
}

库合约

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.2;

library Math {
    function max(uint x, uint y) internal pure returns (uint) {
        return x >= y ? x : y;
    }
}

contract Test {
    function testMax(uint x, uint y) external pure returns (uint) {
        return Math.max(x, y);
    }
}

library ArrayLib {
    function find(uint[] storage arr, uint x) internal view returns (uint) {
        for(uint i = 0; i < arr.length; i++) {
            if (arr[i] == x) {
                return i;
            }
        }
        revert("not found");
    }
}

contract TestArray {
    uint[] public arr = [3, 2, 1];

    function testFind() external view returns (uint i) {
        return ArrayLib.find(arr, 2);
    }
}

//更方便的写法
contract TestArray2 {
    using ArrayLib for uint[];
    uint[] public arr = [3, 2, 1];

    function testFind() external view returns (uint i) {
        return arr.find(2);
    }
}

hash运算

keccak256

tip：在做hash运算进行编码时，使用abi.encodexxxx编码时，不同的编码方式出来的结果不一致

image-20240630194319168

可以看到一个会补0，另一个不会补0。

那么使用encodePacked对"AAAA", "BBB" "AAA", "ABBB"编码，出来的结果会是一样的。如果在这个的基础上再次进行hash运算，就会导致hash碰撞。所以编码时比较好的方式是采用abi.encode，或者在要编码的字符串之前添加uint等方式来隔开。

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.2;

contract HashFunc {
    function hash(string memory text, uint num, address addr) external pure returns (bytes32) {
        return keccak256(abi.encodePacked(text, num, addr));
    }

    function encode(string memory text1, string memory text2) external pure returns (bytes memory) {
        return abi.encode(text1, text2);
    }
    function encodePacked(string memory text1, string memory text2) external pure returns (bytes memory) {
        return abi.encodePacked(text1, text2);
    }
}

验证签名

对一个消息签名分为四步

将消息签名，message to sign
hash(message)
sign(hash(message), private key) | offchain 把消息和私钥签名，在链下完成
恢复签名 ecrecover(hash(message), signature) == signer ，然后验证signer和你期望的是否一致

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.2;

contract Verifysign {
    function verify(address _signer, string memory _message, bytes memory _sign) external pure returns (bool) {
        bytes32 messageHash = getMessageHash(_message);
        bytes32 ethSignedMessageHash = getEthSignedMessageHash(messageHash);
        return recover(ethSignedMessageHash, _sign) == _signer;
    }
    function getMessageHash(string memory _message) public pure returns (bytes32) {
        return keccak256(abi.encodePacked(_message));
    }
    function getEthSignedMessageHash(bytes32 _messageHash) public pure returns (bytes32) {
        return keccak256(abi.encodePacked(
            "\x19Ethereum Signed Message:\n32",
            _messageHash)); //进行两次hash的原因可能是在数学界一次hash已经有被破解的可能性了
    }

    function recover(bytes32 _ethSignedMessageHash, bytes memory _sign) public pure returns (address) {
        (bytes32 r, bytes32 s, uint8 v) = _split(_sign);
        return ecrecover(_ethSignedMessageHash, v, r, s);
    }

    function _split(bytes memory _sign) internal pure returns (bytes32 r, bytes32 s, uint8 v) {
        require(_sign.length == 65, "invalid signature length");

        assembly {
            r := mload(add(_sign, 32))
            s := mload(add(_sign, 64))
            v := byte(0, mload(add(_sign, 96)))
        }
        
    }
    
}

小结：权限控制合约

自毁合约

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.2;

contract Killer {
    constructor() payable {}

    function kill() external {
        selfdestruct(payable(msg.sender)); //像该地址强制发送ETH，即使你是不接受ETH主币的合约，也会给你
    }

    function testCall() external pure returns (uint) {
        return 123;
    }
}

contract Helper {
    function getBalance() external view returns (uint) {
        return address(this).balance;
    }

    function kill(Killer _kill) external {
        _kill.kill();
    }
}

ERCP20标准合约

ERC20标准包含了一组接口IERC20，只要你的代码实现了全部接口，就代表你满足了ERC20标准

在线IDE

https://remix.ethereum.org/

好用网站、应用第二期

Tue, 10 Sep 2024 00:00:00 GMT

AI网盘检索

AI网盘检索是一个实用的搜索软件；软件支持安卓。它特别强大，可以帮助你轻松找到需要的东西，例如：PPT 模板、Excel 模板、考研学习资料、英语学习资料、摄影学习资料、编程学习资料、图片素材、音频素材等。它使用简单，通过对话的方式交互，非常智能。 ::image{src="/images/apporweb2/app1.jpg" alt="app1"}

要知

要知是一个干净清爽的新闻资讯聚合软件；软件支持安卓、iPhone 、iPad。它一个软件相当于多个软件，界面简单清新，让你拥有纯净舒适的新闻浏览阅读体验；它一直在更新完善，支持每日早报一键播报、热门榜单合集、全网聚合 24 小时热榜、时间轴展示新闻资讯、资讯聚合、卡片设计、横竖排切换、强大的搜索功能、日历样式展示早报回顾。 ::image{src="/images/apporweb2/app2.jpg" alt="app2"}

橙篇

橙篇是一个强大的 AI 助手软件；软件支持安卓、iPhone。它免费好用，支持的功能包括：照片漫改视频、AI 一键创作风格化视频、AI 智能全网搜索、AI 帮你精准筛选总结、AI 今日热点、汇集全网热点事件、AI 为你梳理来龙去脉和多维度解读。它还支持超长文章写作、一键生成万字长文、文档总结回答、超多数量和超多类型的文档快速总结回答、学术搜索、文献期刊搜索。 ::image{src="/images/apporweb2/app3.jpg" alt="app3"}

黄柚水印工具

黄柚水印工具是一个苹果视频去水印软件；软件支持 iPhone。它支持视频去水印，还支持视频编辑、视频提取音频、视频删除音频、视频制作动态壁纸、视频加文字、视频滤镜、视频涂鸦、视频调速、图片编辑、图片去水印、图片模糊、图片像素、图片字符。其中视频去水印支持上百个主流平台，使用简单便捷。 ::image{src="/images/apporweb2/app4.jpg" alt="app4"}

15款冷门稀缺的App

1：直链下载：https://muziqi.lanzoul.com/b0foro70d 密码：myu4

2：百度云链接: https://pan.baidu.com/s/1tznhRtu2Nn2h9_zQJLELUA?pwd=rs1d

3：iOS下载：https://shimo.im/docs/913JMQKxK5i0RRAE/

4：部分安卓手机在安装的时候显示无法安装，可以通过断开网络再安装

好用的网站/应用第一期

Sun, 08 Sep 2024 00:00:00 GMT

现代文转古文大模型 ::image{src="/images/app11.png" alt="现代文转古文大模型"}
subtitleedit开源的视频字幕编辑工具。适用于 Windows 的免费视频字幕编辑器。开箱即用且功能强大，支持创建、调整、同步和翻录字幕，还提供了自动翻译、字幕格式转换和语音识别等功能。 ::image{src="/images/app12.png" alt="视频字幕编辑工具"}
bytesize-icons极小、极简的 SVG 图标集合 ::image{src="/images/app13.png" alt="图标"}
grammar-club 旋元佑老师写的一本英语语法书籍，旨在帮助读者建立扎实的语法基础，适合各个水平的英语学习者。 ::image{src="/images/app14.png" alt="英语语法书籍"}

资源网站导航网盘/磁力/影视/学习/工具

Sun, 08 Sep 2024 00:00:00 GMT

导航页：图欧学习导航：https://tuostudy.upnb.top/ 黑洞导航：https://hddh.link/

阿里云盘论坛：

网盘小站：https://wpxz.top/
羊驼小站：http://xdys88.com.cn/
我的小站：https://pan666.net/
猫狸盘搜：https://www.alipansou.com/
up云搜：https://www.upyunso.com/

优秀的阿里云盘个人资源舱或合集舱：

小小树洞400T：https://docs.qq.com/sheet/DS25FQkJjbkZpUnZh?tab=b4ob6e
柠檬的资源库：http://sj.ysupan.com/
影视资源分享官：https://link3.cc/hygf888
网盘资源合集：https://p.kdocs.cn/s/VH4JIBAA64
学习资源船舱：https://link3.cc/studyship
学习资源五大仓：https://tuostudy.top/音范丝：https://www.yinfans.cc/
             https://www.yinfans.me/
             https://www.yinfans.net/
布谷TV：https://www.bugutv.org/
最爱片源网：https://www.z2pyw.com/
4K世界：https://www.4khdr.cn/
送个：
茶杯狐：https://cupfox2.com/KK小站：https://kkxz.vip/
网盘资源合集：https://p.kdocs.cn/s/VH4JIBAA64
磁力猫：clm.la

bt seed

https://www.3bt0.com/
这个主打bt
https://www.btnull.org/
无名小站，也是bt
https://www.bdys10.com/
这个也是bt，体积小一些，清晰度差一些。
https://wpxz.top/
这个是阿里云盘。

seed、电影

磁力搜索：
（手机访问，资源最全）https://www.btnull.org/
（知名站点，体积小巧）https://btbtt12.com/
网盘搜索：
https://yiso.fun/
https://zhaoziyuan.me/
还有更绝的，能直接搜索全网在线播放
http://soupian.xyz/
不太灵 
butailing.com
阿里云资源
https://www.aliyundrive.com/s/3gTt6wdZoFY/folder/63fafab8f325089a9cc0477d9d566735f85cc4f8
特殊种子搜索
sukebei.nyaa.SI

片库（推荐）---网盘/种子/磁力

https://www.btnull.si/
@哔嘀影视（推荐）---种子/磁力/电驴
https://www.bdys10.com/
@MP4电影---磁力/电驴
https://www.wemp4.com/
@深影驿站（原创字幕组）---网盘
https://sysub.vip/
@皮皮虾（推荐）---网盘
https://ppxzy.net/
@我的小站（推荐）---网盘
https://pan666.net/
@小纸条（推荐）---网盘
https://ali.gitcafe.ink/
@盘友圈---网盘
https://panyq.com/
低端影视（在线）---网盘
https://ddys.pro/
@蜜柑计划（动漫）---种子
https://mikanani.me/
@ACG（动漫）---种子
https://acg.rip/
@不太灵---种子
https://www.1bt0.com/
@BT之家---种子
http://btbtt19.com/

（全网最全最详细）天涯神贴合集1000篇 | 超全合集，无需解压

Sun, 08 Sep 2024 00:00:00 GMT

天涯社区创办于1999年，要知道，那时候的中国互联网才刚刚起步，BAT 甚至还没有创建。

到2007年时，天涯社区的注册用户就已经突破了2000万，天涯给了自己一个身份：全球最大的中文互联网社区，喊出了“全球华人的网上家园”口号。

::image{src="/images/tianya/tianya.jpeg" alt="tianya"}

天涯社区曾经捧红过以“芙蓉姐姐”为代表的第一代网红。

截至2013年8月，天涯社区注册用户数就高达8500万。

当年的天涯部分大神们名单： 1.经济类: KK、喜数女、缠中说禅、雕爷、高铭、新垣平、大江宁静、Mark、波得莱神，KU神，0715，白马，咸聊，蛮族勇士 2.神秘类: 神奇的老贼头、个三、天下霸唱、何马、四书五经、乾泰丰、老夜、li非凡、猪头大拿、脚踏阴阳 3.煮酒论史类: 当年明月、南派三叔、天下霸唱、燕垒生，慕容雪春，蜘蛛，小汗、小鹏、宁财神、神之手123、雨花石。 4.其他类: 我是骗子他祖宗、赚钱7788、上海高隐、麻帝等

其中不乏这些现在依然很有影响力的大V和作家们，当年全部成名于天涯，虽说是相互成就，但侧面也反映出天涯的多样性，包容性，尤其是小说这一类，不仅在当时，哪怕是现在，也是行业第一的水准。

::image{src="/images/tianya/tianya2.png" alt="tianya2"}

天涯社区生于 PC 时代，死于移动互联网（手机）。在移动互联网的冲击下，论坛没有了往日的风光，现在大家的时间都被手机直播、短视频等占据了，逛论坛的习惯渐渐的没有了。天涯论坛也终于在2022年11月22日18时正式宣布永久关闭...随之消失的还有一代人的青春...

不过，幸运的是我和我的团队把这些天涯神贴收集整理在了一起，基本上是目前能找到的天涯神贴合集最全的了，而且是PDF版本免解压点开直接看，共计800w+字1000篇。

::image{src="/images/tianya/tianya3.png" alt="tianya3"}

其中比较经典的天涯十大神贴： 1、【大鹏金翅明王】系列：谈论了房价现象，同时也分享了一些人生经验、社会法则、个人感悟等，发人深省 2、【 kkkndme】系列：写于2010年左右，用浅显的话对房地产市场进行了分析 3、【灵宠灵草】：带有灵异性质，讲述了如何培养灵宠、灵草，比如芦荟能带来好运、乌龟能带来财运，如何把鲤鱼、泥鳅和猫培养成灵兽等等 4、【我当道士那些年】：从主角出生被百鬼缠身，到之后拜师，修炼长大等一系列故事，非常细腻 5、【他手机里有爱人，有秘密，有感情】：情感类帖子，刻在DNA里的意难平 6、【我是一名杀手，仅此而已】：讲述一个杀手的故事，仿佛令人身临其境，点击破千万 7、【感谢小月月这样一个极品的朋友】：横空出世的极品女小月月，刷新了诸多网络红人造的雷人纪录 8、【客房，大三租房灵异经历】：莲蓬鬼话板块神贴，讲述灵异故事 9、【宜昌鬼事】：描述了上世纪一些离奇诡异的事件，引人入胜 10、【英雄末路：历史上那些大人物之死】：历史类

下载链接：https://pan.quark.cn/s/4072a2ff82ee