[关闭]
@zhongdao 2017-12-21T08:00:55.000000Z 字数 84484 阅读 7009

part2: 区块链设计与实现笔记v2

未分类

拟定目录大纲:
Part1: 比特币与区块链
1. 比特币技术原理
2. 比特币协议
3. 硬分叉
4. 侧链设计原理
5. 侧链开发
6. 智能合约设计原理
7. 智能合约开发
8. 区块链生态介绍
9. 区块链应用

Part2: 设计与实现笔记
1. 区块链原理机制与背景
2. 区块链基本结构
3. 加解密算法实现
4. 区块数据结构从定义到初步实现
5. 区块节点读取验证与挖矿
6. 节点和应用程序之间协议
7. 节点之间沟通

Part3: 区块链相关基础知识
1. 计算机基础知识
1. Linux相关说明
3. 密码学相关说明
4. 程序开发语言相关说明
5. 虚拟机语言

第三期课程:
区块链设计与实现笔记v1： https://www.zybuluo.com/zhongdao/note/933849

Part1: 比特币与区块链v2
Part2: 区块链设计与实现笔记v2 https://www.zybuluo.com/zhongdao/note/992471
Part3: 区块链相关基础知识v2

若有更正请联系: 李君
邮件: junlicn@foxmail.com
2017.12.20

实际自动导航目录:

0.前言

0.1 内容来源

区块链技术开发公开课:
授课老师: 辕询, 李涛涛
直播地址: http://itgege.gensee.com/webcast/site/entry/join-b0836bdd98c24eb78c67d3a0993b1589

0.2 笔记v1缘起

根据老师公开课上讲的内容, 构造一个完整笔记,便于学习和掌握. 随着课程的进展, 不断添加和整理.
此文档的完整内容来自:公开的课程内容、源代码，资料、搜索引擎搜到的资料、相关技术书籍上的资料等, 我对内容做了整理,使得易于阅读和条理化，对于部分代码添加了注释和自己的理解, 若有错误请沟通纠正。
其中引用到一些同学的笔记内容或者截图，其他笔记内容来源者包括: 程书芝, 袁丁逸涵, 郜晶, liuhongshuo, 谭东雷, 潘杰 ...
笔记编写过程中有张博成,pz100等对错误之处给出了的修订建议.
要特别感谢老师依据开源传统所教授的内容.

0.3 笔记v2缘起

区块链技术开发公开课开始了第四期,然而三期因为时间精力等因素记得不全,再加上因为编辑内容太多,需要分开成几部分，重新进行规划。
Part1 收集整理比特币的相关技术与知识，入门，背景以及深入的技术介绍。
Part2 以课程老师的讲解和实现为主记录的笔记。
Part3 以区块链实现过程当中所需的基础知识为主，涵盖老师所讲的语言，系统，编译原理，密码学等基础知识，也包括从互联网，书本上的相关知识分类整理。

0.4 内容编写原则与目的

从理论到程序实现，清晰明了，易于理解，从比特币，区块链的基础知识介绍到依循老师所讲的内容自己创建一个区块链，同时补充所需的计算机基础知识，从密码学，算法，Linux系统操作, 程序开发语言到虚拟机语言等。

0.5 每次课程摘要

  1. 主要内容：
  2. 1.     区块链的基本结构；
  3. 2.     为什么私钥最重要，以及随机数 –> 私钥 -> 公钥 -> 地址的生成过程；
  4. 3.     文件系统的结构；
  5. 4.     每个区块链程序都由三种基本协议组成
  6. a)     A协议：节点内部的规则，数据格式、交易规则、加密/解密算法等；
  7. b)     B协议：应用程序与节点沟通的协议；
  8. c)     C协议：节点之间沟通的协议；
  9. 5.     区块间隔和冲突处理机制；
  10. 6.     计算机的数据存储及区块链数据结构。

1. 区块链原理与背景

1.0 设计理念

During system design, the major data structure for the software are identified; without these, the system modules cannot be mean
software cannot be meaningfully repaired only rewritten.

从2008年末中本聪的白皮书发出到2009年初中本聪的程序完成,有4个月时间。
开始设计好了，后期的维护成本会很小。
一如Unix的设计理念。
亦来云没有文件和文件夹的概念， 只有服务。

出于教学的目的，为了便于理解，CCN设计得非常简洁，保留了核心的部分，去掉了不必要的部分。

2.区块链基本结构

2.1 区块图示

结构示意:
此处输入图片的描述

或者如下图示意:
image_1btodhc8onfa1mdp10u21pa11ckqm.png-83.1kB
Merkle root 存的hash是为了确保身部所有的交易无法被修改.
Previous Hash是对前一个区块的头header的hash.

4个连续区块及相应交易的例子展示
image_1buj18dmu14ub7v4d511avk1aaim.png-35.9kB
image_1buj1ebcppjaj9j10451b32hv513.png-35.6kB

2.2 区块定义

ConciseCoin（CCN）是一个数码货币系统。

BLOCK := HEAD, TRANSACTION*
HEAD := current(32), nonce(4), previous(32), target(32), time(4), valence(4)
TRANSACTION := A, B, C, INPUT*, OUTPUT*
INPUT := A, index(4), B, public(B), C, signature(C), transaction(32)
OUTPUT := A, B, address(B), amount(8) 

  1. HEAD - 5 attribute   108BYTE
  2. BODY - 1 or more TRANSACTION
  3. TRANSACTION  - 1 or more  INPUT and OUTPUT
  4.             COINBASE  (创始, 挖矿奖励)
  1. HEAD
  2.    CURRENT: 32
  3.    NONCE: 4
  4.    PREVIOUS: 32 -> completely zero if genesis block
  5.    TARGET: 32
  6.    TIME: 4
  8. BODY
  9.    TRANSACTION #1
  10.       INPUTS: 1个
  11.          INDEX: 4 -> completely zero
  12.          PUBLIC: 0
  13.          SIGNATURE: 0
  14.          TRANSACTION: 32 -> completely zero
  15.       OUTPUTS: 1个
  16.          ADDRESS: 灵活 -> miner's address
  17.          AMOUNT: 8 -> 50 或者 100 (挖矿奖励)
  19.    TRANSACTION #2
  20.    TRANSACTION #3
  21.       INPUTS: 1个或者多个
  22.          INDEX: 4
  23.          PUBLIC: 灵活
  24.          SIGNATURE: 灵活
  25.          TRANSACTION: 32
  26.       OUTPUTS: 1个或者多个
  27.          ADDRESS: 灵活
  28.          AMOUNT: 8

2.3 密码学算法实现步骤简要说明

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

加密和解密最大的危险就是是否产生真正的随机数.

  1. a = open ("/dev/arandom")  打开文件
  2. b = read (a 128)       随机数包括[0 - 256)
  3. c = get.private (b)    私钥
  4. d = get.public (c)     公钥
  5. e = get.address (d)    地址

2.4 交易过程说明

2.4.1 交易过程图示

image_1btoaked7g6m15uo19okr2tsirm.png-233.9kB
每一个人随时控制N个地址，每一个地址随时包含N个碎片。

2.4.2 区块中第1个交易用于矿工

  1. 第1个交易是矿工奖励, Transaction中的output要设为矿工的地址, 这里的实现用公钥代替.
  2. 所以构建时,要取得矿工的地址.

3. 密码学算法实现

3.1. 密码学相关说明

密码学在区块链的应用：hash函数 椭圆曲线数字签名

image_1btobo6mh1cpr16ui1lvo3erlvj1g.png-39kB

3.1.1 hash的应用

1.Tx的hash和Merkle root
2.地址生成 —>节约空间
3.挖矿 hash(x||N)难于解决易于验证
4.连接

image_1btobljiu1bq0i1t1q3c1g5l12tn13.png-155.3kB

3.1.2 椭圆曲线

Elliptal Cirue Digital Signature Algorthim
ECC: Elliptal Curve Crypeogaphy. 加解密
ECDSA: 签名和验证的.

超级计算机速度: 4万亿/s
找到碰撞 需要计算 4万亿年.

3.1.3 安全库说明

不是操作系统或者标准化的函数库叫做第三方库.
libtomcrypt是个第三方库.
1. Libtomcrypt
2. OpenSSL

3.2 加解密算法实现代码说明

3.2.1 md5

md5 输出 128bit, 每8bit为1个字节, 也就是16个字节, 1个字节2^8 [0,256)用2个字母表示(00-ff), 共计32个字母
换成sha256时, 需要把16字节out数组改为32字节out

  1. // MD5输出128bit  SHA1输出160bit SHA256输出256bit .    
  2. // c语言里 %x表示16进制, 会输出2个字母.  
  3. // SHA256 输出 256bit, 32个字节, 64个字符.  
  5. #include "tomcrypt.h"
  7. int main(int count, char **arguments)
  8. {
  9.   hash_state md;
  10.   unsigned char *in = "lijun", out[16];
  12.   /* setup the hash */
  13.   md5_init(&md);
  15.   /* add the message */
  16.   md5_process(&md, in, strlen(in));
  18.   /* get the hash in out[0..15] */
  19.   md5_done(&md, out);
  21.   for(int i = 0; i < 16; i++)
  22.   {
  23.      printf("%02x", out[i]);    // %02x 表示输出2个字符的16进制,否则0时会省略掉.
  24.   }
  25.   printf("\n");
  27.   return 0;
  28. }
  29. }

3.2.2 sha256

  1. #include "stdio.h"
  2. #include "stdlib.h"
  3. #include "string.h"
  4. #include "tomcrypt.h"   //密码库
  5. char *get_file(char *path){             //读取文件
  6.         FILE *file;
  7.         int length;
  8.         char *contents;
  10.         //获取文件长度
  11.         file = fopen(path , "r+");
  12.         fseek(file , 0 , SEEK_END);     //跳到文件结尾
  13.         length = ftell(file);           //给出文件长度
  14.         fseek(file , 0 ,SEEK_SET);      //再跳回文件开头
  16.         //分配内存，读取文件 
  17.         //! 最初的代码是length+1, 改为length
  18.         contents = malloc(length);  //给文件分配内存
  19.         fread(contents , 1 , length , file);
  21.         //关闭文件, 系统同时打开的文件个数是有限的,约4900+
  22.         fclose(file);
  23.         return contents ;               //返回文件内容
  24. }
  25. void main(){                            //对文本进行Hash加密
  26.         char *input , *output;
  27.         int length;
  29.         output = malloc(1000);          //分配1000字节的内存
  30.         length = 1000;
  31.         input = get_file("essay.txt");  //读取文件
  33.         register_hash(&sha256_desc);    //激活哈希函数，必须！！
  34.         hash_memory(find_hash("sha256") , input , strlen(input) , output , &leng)
  36.         printf("%s" , output);
  37.         //printf("%d%c" , length , 10); //打印长度
  38.         //printf("%02x%c" , output[0] , 10);    //打印第一个字符，%02x：十六进制
  39. }

3.2.3 获取私钥

  1. unsigned char *get_private(unsigned int *length)
  2. {
  3.    prng_state random;  // 随机生产器的状态.
  4.    ecc_key key;      //保存私钥和公钥的数据结构
  5.    unsigned char *buffer;
  7.    buffer = malloc(*length = 1000);
  8.    // 随机生成器状态, 系统随机生成器, ?, 保存位置 
  9.    ecc_make_key(&random, find_prng("sprng"), 32, &key);  //创建一个私钥
  10.    // 把其私钥转换成可打印的字符串.
  11.    ecc_export(buffer, length, PK_PRIVATE, &key);
  13.    return buffer;
  14. }

3.2.4 获取公钥

  1. unsigned char *get_public(unsigned int *length, unsigned char *private)
  2. {
  3.    ecc_key key;
  4.    unsigned char *buffer;
  6.     //导入私钥
  7.    ecc_import(private, *length, &key);
  8.    buffer = malloc(*length = 1000);
  9.    // 输出公钥
  10.    ecc_export(buffer, length, PK_PUBLIC, &key);
  12.    return buffer;
  13. }

3.2.5 编码输出

Extra libraries: TomsFastMath library
每次使用tomcryp函数库时, 必须要有如下一行,这是它的固定规则:
ltc_mp = tfm_desc;

将private, public输出的生字节, 用base64转换成ASCII. 便于和其他人共享. 

  1. void main()
  2. {
  3.    unsigned char *private, *public, *buffer;
  4.    unsigned int length_private, length_public, length_buffer;
  6.    ltc_mp = tfm_desc;
  7.    register_prng(&sprng_desc);   //激活函数
  8.    register_hash(&sha256_desc);
  10.    private = get_private(&length_private);
  11.    length_public = length_private;
  12.    public = get_public(&length_public, private);
  14.    buffer = malloc(1000);
  15.    // tomcrypt库函数_ecc_xxx 生产出自己的私钥,  生成的是生字节.
  17.    memset(buffer, 0, 1000);
  18.    base64_encode(private, length_private, buffer, &length_buffer);
  19.    printf("%s%c%c", buffer, 10, 10);
  21.    memset(buffer, 0, 1000);
  22.    base64_encode(public, length_public, buffer, &length_buffer);
  23.    printf("%s%c", buffer, 10);
  24. }

4. 区块数据结构从定义到初步实现

4.1 整体结构定义与区块交易示例

4.1.1 各部分具体定义

BLOCK:

字段名: HEAD BODY(TRANSACTIONS*)
说明: 头部 身部(多个交易)

HEAD:

字段说明 current nounce previous target time valence
说明 BODY的sha256输出 挖矿难度 前个区块的ID 越大难度越小 ?时间 交易个数
长度(字节) 32 4 32 32 4 4

总长：108 (BTC为80）

Transaction

字段名 A B C Input* Output*
说明 总长度(含自己) 输入个数 输出个数 输入列表 输出列表
长度(字节) 4 4 4 B C

实例:
input: #1. 30, #2 40, #3 50
output: #1 100, #2 19 (隐含的手续费=sum(input)-sum(output) )
数据结构表示:
Head, coinbase, A, 3, 2, input#1, input#2, input#3, output#1,output#2
coinbase是第一个交易.

构造区块的顺序:
第2个及之后交易, coinbase, 最后造头
因为要计算手续费, 还有由所有交易构造merkle tree root

INPUT:

字段名 A (碎片号) index B public C Signature Transaction的sha256
说明 总长(交易中的第几个碎片) 第几个Input public长度 公钥 签名长度 签名 交易的hash, merkle root
长度(字节) 4 4 4(33 or 65) B 4 C(<=73,不固定) 32

OUTPUT:

字段名 A B Address Amount
说明 总长度 地址长度 交易地址 交易数量
长度(字节) 4 4 B 8

4.1.2 区块交易实例

  1. #1: 3930
  2.    [8629] -> YUANXUN(100)
  4. #2: 4479
  5.    [4140] -> YUANXUN(100)
  6.    [7159] YUANXUN/8629/1 -> YUANXUN(99) PANPENG(1)
  8. A index B public C signature transaction

4.3.2 头部和身部的另一种定义

整体

  1. HEAD - 6 attribute   108BYTE
  2. BODY - 1 or more TRANSACTION
  3. TRANSACTION  - 1 or more  INPUT and OUTPUT
  4.             COINBASE  (创始, 挖矿奖励)

头部和身部具体

  1. HEAD
  2.    CURRENT: 32
  3.    NONCE: 4
  4.    PREVIOUS: 32 -> completely zero if genesis block
  5.    TARGET: 32
  6.    TIME: 4
  7.    VALENCE: 4
  9. BODY
  10.    TRANSACTION #1
  11.       INPUTS: 1个
  12.          INDEX: 4 -> completely zero
  13.          PUBLIC: 0
  14.          SIGNATURE: 0
  15.          TRANSACTION: 32 -> completely zero
  16.       OUTPUTS: 1个
  17.          ADDRESS: 灵活 -> miner's address
  18.          AMOUNT: 8 -> 50 huozhe 100
  20.    TRANSACTION #2
  21.    TRANSACTION #3
  22.       INPUTS: 1个或者多个
  23.          INDEX: 4
  24.          PUBLIC: 灵活
  25.          SIGNATURE: 灵活
  26.          TRANSACTION: 32
  27.       OUTPUTS: 1个或者多个
  28.          ADDRESS: 灵活
  29.          AMOUNT: 8

4.1 Head

4.1.1 结构说明

  1. HEAD
  2.    CURRENT: 32
  3.    NONCE: 4
  4.    PREVIOUS: 32 -> completely zero if genesis block
  5.    TARGET: 32
  6.    TIME: 4
  7.    VALENCE: 4

4.1.2 程序数据结构

Head的长度固定是108字节, 所以不需要保存长度.

字段说明 current nounce previous target time valence
说明 BODY的sha256输出,当前block的ID 挖矿难度 前个区块的ID 越大难度越小 ?时间 交易个数
长度(字节) 32 4 32 32 4 4

nounce , target 用于pow, 在链的最初不需要pow, 当有很多个节点创造block时才用到pow,

4.1.3 程序代码

  1. unsigned char *get_head(unsigned char *root)
  2. {
  3.    unsigned char *complete, *y;
  4.    unsigned int *x;
  6.    complete = malloc(104);
  8.    y = malloc(32);
  9.    memcpy(y, root, 32);
  10.    memcpy(complete, y, 32);
  12.    x = malloc(4);
  13.    *x = 0;
  14.    memcpy(complete + 32, x, 4);
  16.    y = malloc(32);
  17.    memset(y, 0, 32);
  18.    memcpy(complete + 36, y, 32);
  20.    y = malloc(32);
  21.    memset(y, 255, 32);
  22.    memcpy(complete + 68, y, 32);
  24.    x = malloc(4);
  25.    *x = time(0);
  26.    memcpy(complete + 100, x, 4);
  28.    return complete;
  29. }

4.2 Body

4.2.1 Transaction-Input

4.2.1.1 结构说明

  1.    TRANSACTION #1 // 第一个区块.
  2.       INPUTS: 1
  3.          INDEX: 4 -> completely zero
  4.          PUBLIC: 0
  5.          SIGNATURE: 0
  6.          TRANSACTION: 32 -> completely zero
  8.    TRANSACTION #2,#3,...  // 之后的区块
  9.       INPUTS: 1个或者以上
  10.          INDEX: 4
  11.          PUBLIC: linghuo
  12.          SIGNATURE: linghuo
  13.          TRANSACTION: 32

4.2.1.2 程序数据结构

字段名 A (总长) index B public C Signature Transaction的sha256
说明 总长 第几个Input public长度 公钥 签名长度 签名 交易的hash, merkle root
长度(字节) 4 4 4 B 4 C 32

4.2.1.3 程序代码

  1. unsigned char *get_input(unsigned int *total)
  2. {
  3.    // A index B public C signature transaction
  5.    char *private, *public, *complete;
  6.    int length;
  8.    int *x;
  9.    unsigned char *y;
  11.    private = get_private(&length);
  12.    public = get_public(&length, private);
  14.    complete = malloc(*total = 48 + length);
  16.    x = malloc(4);
  17.    *x = 48 + length;
  18.    memcpy(complete, x, 4); // 放置总长
  20.    x = malloc(4);
  21.    *x = 0;
  22.    memcpy(complete + 4, x, 4);  //放置Index长
  24.    x = malloc(4);
  25.    *x = length;
  26.    memcpy(complete + 8, x, 4); // 放置public的长度 
  28.    y = malloc(length);
  29.    memcpy(y, public, length);
  30.    memcpy(complete + 12, y, length); // 放置公钥public 
  32.     //!! 应该放置signature 的长度, 和 signature, 因为还未讲到signature的用法, 暂时先不放.
  33.    x = malloc(4);
  34.    *x = 0;
  35.    memcpy(complete + 12 + length, x, 4); //放置Signature长度.
  37.    y = malloc(32);
  38.    memset(y, 0, 32);
  39.    memcpy(complete + 16 + length, y, 32); // 放置Transaction ??
  41.    return complete;
  42. }

4.2.2 Transaction-Output

4.2.2.1 结构说明

第1个交易中的Output

  1.       OUTPUTS: 1个
  2.          ADDRESS: 大小不定 -> 矿工地址
  3.          AMOUNT: 8字节 -> 100或者50

第2+个交易中的Output

  1.       OUTPUTS: 1个
  2.          ADDRESS: 大小不定 -> 地址
  3.          AMOUNT: 8字节

4.2.2.2 程序数据结构

字段名 A B Address Amount
说明 总长度 地址长度 交易地址 交易数量
长度(字节) 4 4 B 8

4.2.2.3 代码

  1. unsigned char *get_output(unsigned int *total)
  2. {
  3.    unsigned char *private, *public, *complete, *y;
  4.    unsigned int length, *x, z;
  6.    private = get_private(&length);
  7.    public = get_public(&length, private);
  9.    // len_A len_B address amount
  10.    // 4 + 4 + B + 8
  12.    complete = malloc(*total = 16 + length);
  14.    x = malloc(4);
  15.    *x = 16 + length;
  16.    memcpy(complete, x, 4); // 设置总长 A
  18.    x = malloc(4);
  19.    *x = length;
  20.    memcpy(complete + 4, x, 4); // 设地址长度 B
  22.    y = malloc(length);
  23.    memcpy(y, public, length);
  24.    memcpy(complete + 8, y, length); // 设置地址, 暂时把公钥作为地址
  26.    y = malloc(8);
  27.    z = 1000;
  28.    memcpy(y, &z, 4);
  29.    memset(y + 4, 0, 4);
  30.    memcpy(complete + 8 + length, y, 8); // 设置8字节的交易数量
  32.    return complete;
  33. }

4.2.3 Transaction

4.2.3.1 结构说明

  1.    TRANSACTION #1
  2.       INPUTS: 1
  3.          INDEX: 4 -> completely zero
  4.          PUBLIC: 0
  5.          SIGNATURE: 0
  6.          TRANSACTION: 32 -> completely zero
  7.       OUTPUTS: 1
  8.          ADDRESS: linghuo -> miner's address
  9.          AMOUNT: 8 -> 50 huozhe 100
  11.    TRANSACTION #2
  12.    TRANSACTION #3
  13.       INPUTS: yige huozhe yishang
  14.          INDEX: 4
  15.          PUBLIC: linghuo
  16.          SIGNATURE: linghuo
  17.          TRANSACTION: 32
  18.       OUTPUTS: yige huozhe yishang
  19.          ADDRESS: linghuo
  20.          AMOUNT: 8

4.2.3.2 程序数据结构

Transaction

字段名 A B C Input* Output*
说明 总长度(含自己) 输入个数 输出个数 输入列表 输出列表
长度(字节) 4 4 4 B C

结构有变更.

4.2.3.3 程序代码(旧代码,待更改)

  1. unsigned char *get_transaction(unsigned int *total)
  2. {
  3.    unsigned char *input, *output, *complete, *y;
  4.    unsigned int length_input, length_output, *x;
  6.    input = get_input(&length_input);
  7.    output = get_output(&length_output);
  9.    complete = malloc(*total = 12 + length_input + length_output);
  11.    x = malloc(4);    // A
  12.    *x = 12 + length_input + length_output;
  13.    memcpy(complete, x, 4);
  15.    x = malloc(4);
  16.    *x = 1;          // B, 只有1个输入
  17.    memcpy(complete + 4, x, 4);
  19.    x = malloc(4);
  20.    *x = 1;         // C 只有一个输出
  21.    memcpy(complete + 8, x, 4);
  23.    y = malloc(length_input);     // input
  24.    memcpy(y, input, length_input);
  25.    memcpy(complete + 12, y, length_input);
  27.    y = malloc(length_output);    // output
  28.    memcpy(y, output, length_output);
  29.    memcpy(complete + 12 + length_input, y, length_output);
  31.    return complete;
  32. }

4.4 程序开发实现

4.4.1 常用函数设计

为了方便处理区块字段, 设计了相关函数. 简化常见的操作.

  1. char *string_create(char *old, int length)
  2. char *string_create_improper(char *old)
  3. char *string_create_progression(int a)
  4. int string_measure(char *buffer)
  5. void string_update(char *object, char *buffer, int length)
  6. void string_update_4(char *object, int quantity)
  7. void string_update_8(char *object, uint64_t quantity)
  8. void string_update_initial(char *object, char *initial)
  9. char *string_eject(char *object)
  10. int scan(char *source)

4.4.2 区块及示例区块数据生成

需要说明的是, 因为老师对随机数字比字母单词更敏感,所以实例程序中的变量很多采用了数字来表示. 并无其他深意.

  1. #define TFM_DESC
  3. #include "stdio.h"
  4. #include "stdlib.h"
  5. #include "string.h"
  6. #include "tfm.h"
  7. #include "tomcrypt.h"
  9. char *string_create(char *old, int length)
  10. {
  11.    char *new;
  12.    int *_6157;
  14.    new = malloc(length + 4) + 4;
  15.    memcpy(new, old, length);
  17.    _6157 = (int *) (new - 4);
  18.    *_6157 = length;
  20.    return new;
  21. }
  23. char *string_create_improper(char *old)
  24. {
  25.    char *new;
  26.    int *_7193;
  28.    new = malloc(strlen(old) + 4) + 4;
  29.    memcpy(new, old, strlen(old));
  31.    _7193 = (int *) (new - 4);
  32.    *_7193 = strlen(old);
  34.    return new;
  35. }
  37. char *string_create_progression(int a)
  38. {
  39.    char *c;
  40.    int *_3919;
  42.    c = malloc(a + 4) + 4;
  44.    _3919 = (int *) (c - 4);
  45.    *_3919 = 0;
  47.    return c;
  48. }
  50. int string_measure(char *buffer)
  51. {
  52.    int *_4721;
  54.    _4721 = (int *) (buffer - 4);
  56.    return *_4721;
  57. }
  59. void string_update(char *object, char *buffer, int length)
  60. {
  61.    int *_9492;
  63.    _9492 = (int *) (object - 4);
  64.    memcpy(object + *_9492, buffer, length);
  65.    *_9492 += length;
  66. }
  68. void string_update_4(char *object, int quantity)
  69. {
  70.    int *_7751, *_2888;
  72.    _7751 = (int *) (object - 4);
  73.    _2888 = (int *) (object + *_7751);
  74.    *_2888 = quantity;
  75.    *_7751 += 4;
  76. }
  78. void string_update_8(char *object, uint64_t quantity)
  79. {
  80.    int *_7751;
  81.    uint64_t *_2888;
  83.    _7751 = (int *) (object - 4);
  84.    _2888 = (uint64_t *) (object + *_7751);
  85.    *_2888 = quantity;
  86.    *_7751 += 8;
  87. }
  89. void string_update_initial(char *object, char *initial)
  90. {
  91.    int *_8478, *_5970;
  93.    _8478 = (int *) (object - 4);
  94.    _5970 = (int *) initial;
  96.    memcpy(object + *_8478, initial, *_5970);
  97.    *_8478 += *_5970;
  98. }
  100. char *string_eject(char *object)
  101. {
  102.    char *new;
  103.    int *_6558;
  105.    _6558 = (int *) (object - 4);
  106.    new = malloc(*_6558);
  107.    memcpy(new, object, *_6558);
  109.    return new;
  110. }
  112. char *get_maximal()
  113. {
  114.    char *digest;
  116.    digest = malloc(32);
  117.    memset(digest, 255, 32);
  119.    return digest;
  120. }
  122. char *get_minimal()
  123. {
  124.    char *digest;
  126.    digest = malloc(32);
  127.    memset(digest, 0, 32);
  129.    return digest;
  130. }
  132. int scan(char *source)
  133. {
  134.    int *size;
  136.    size = (int *) source;
  138.    return *size;
  139. }
  141. char *get_file(char *path) {
  143.    FILE *file;
  144.    int length;
  145.    char *contents;
  147.    file = fopen(path, "r+");
  148.    fseek(file, 0, SEEK_END);
  149.    length = ftell(file);
  150.    fseek(file, 0, SEEK_SET);
  152.    contents = malloc(length + 1);
  153.    fread(contents, 1, length, file);
  155.    fclose(file);
  157.    return contents;
  158. }
  159. // same info, after ecc signature, output different sig length because of random number.
  160. char *get_signature(char *object, char *private)
  161. {
  162.    prng_state _1307;
  163.    ecc_key _1317;
  164.    int _1648;
  165.    char *_5497;
  167.    _5497 = malloc(1000);
  168.    _1648 = 1000;
  170.    ecc_import(private, string_measure(private), &_1317);
  171.    ecc_sign_hash(object, string_measure(object), _5497, &_1648, &_1307, find_prng("sprng"), &_1317);
  173.    return string_create(_5497, _1648);
  174. }
  176. unsigned char *get_private(unsigned int *length)
  177. {
  178.    prng_state random;
  179.    ecc_key key;
  180.    unsigned char *buffer;
  182.    buffer = malloc(*length = 1000);
  183.    ecc_make_key(&random, find_prng("sprng"), 32, &key);
  184.    ecc_export(buffer, length, PK_PRIVATE, &key);
  186.    return buffer;
  187. }
  189. unsigned char *get_public(unsigned int *length, unsigned char *private)
  190. {
  191.    ecc_key key;
  192.    unsigned char *buffer;
  194.    ecc_import(private, *length, &key);
  195.    buffer = malloc(*length = 1000);
  196.    ecc_export(buffer, length, PK_PUBLIC, &key);
  198.    return buffer;
  199. }
  201. char *build_input(int _8626, char *_5409, char *_4051, char *_3775)
  202. {
  203.    char *_9016;
  204.    int *_1933;
  206.    _9016 = malloc(48 + string_measure(_5409) + string_measure(_4051));
  207.    _1933 = (int *) _9016;
  208.    *_1933 = 48 + string_measure(_5409) + string_measure(_4051);
  209.    _1933 = (int *) (_9016 + 4);
  210.    *_1933 = _8626;
  211.    _1933 = (int *) (_9016 + 8);
  212.    *_1933 = string_measure(_5409);
  213.    memcpy(_9016 + 12, _5409, string_measure(_5409));
  214.    _1933 = (int *) (_9016 + 12 + string_measure(_5409));
  215.    *_1933 = string_measure(_4051);
  216.    memcpy(_9016 + 16 + string_measure(_5409), _4051, string_measure(_4051));
  217.    memcpy(_9016 + 16 + string_measure(_5409) + string_measure(_4051), _3775, 32);
  219.    return _9016;
  220. }
  222. char *build_output(char *_7095, uint64_t _8432)
  223. {
  224.    char *_3516;
  225.    int *_8347;
  226.    uint64_t *_9910;
  228.    _3516 = malloc(16 + string_measure(_7095));
  229.    _8347 = (int *) _3516;
  230.    *_8347 = 16 + string_measure(_7095);
  231.    _8347 = (int *) (_3516 + 4);
  232.    *_8347 = string_measure(_7095);
  233.    memcpy(_3516 + 8, _7095, string_measure(_7095));
  234.    _9910 = (uint64_t *) (_3516 + 8 + string_measure(_7095));
  235.    *_9910 = _8432;
  237.    return _3516;
  238. }
  240. char *get_sha256(char *buffer, int size)
  241. {
  242.    hash_state resource;
  243.    char *digest;
  245.    digest = malloc(32);
  246.    sha256_init(&resource);
  247.    sha256_process(&resource, buffer, size);
  248.    sha256_done(&resource, digest);
  250.    return digest;
  251. }
  253. char *get_md5(char *buffer, int size)
  254. {
  255.    hash_state resource;
  256.    char *digest;
  258.    digest = malloc(16);
  259.    md5_init(&resource);
  260.    md5_process(&resource, buffer, size);
  261.    md5_done(&resource, digest);
  263.    return digest;
  264. }
  266. char *get_merkle_root(char *old, int size)
  267. {
  268.    char *new, output[32], input[64];
  269.    int index;
  271.    if (size == 1) {
  273.       return old;
  274.    }
  276.    if (size % 2) {
  278.       new = malloc(32 * (size + 1));
  279.       memcpy(new, old, size * 32);
  280.       memcpy(new + size * 32, old + (size - 1) * 32, 32);
  282.       return get_merkle_root(new, size + 1);
  283.    }
  285.    new = malloc(32 * size / 2);
  287.    for (index = 0; index < size; index += 2) {
  289.       memcpy(input, old + index * 32, 64);
  290.       memcpy(new + (index / 2) * 32, get_sha256(input, 64), 32);
  291.    }
  293.    return get_merkle_root(new, size / 2);
  294. }
  296. void print_digest(char *digest)
  297. {
  298.    int index;
  300.    for (index = 0; index < 32; index++)
  301.       printf("%02hhx", digest[index]);
  303.    printf("%c", 10);
  304. }
  306. // ------------------
  308. char *transaction_7159(int A, char *B, char *C, char *D, char *lichangli, char *panpeng)
  309. {
  310.    char *input_0, *output_0, *output_1, *transaction;
  312.    input_0 = build_input(A, B, C, D);
  313.    output_0 = build_output(lichangli, 99);
  314.    output_1 = build_output(panpeng, 1);
  315.    transaction = string_create_progression(12 + scan(input_0) + scan(output_0) + scan(output_1));
  316.    string_update_4(transaction, 12 + scan(input_0) + scan(output_0) + scan(output_1));
  317.    string_update_4(transaction, 1);
  318.    string_update_4(transaction, 2);
  319.    string_update(transaction, input_0, scan(input_0));
  320.    string_update(transaction, output_0, scan(output_0));
  321.    string_update(transaction, output_1, scan(output_1));
  323.    return transaction;
  324. }
  326. char *block_3930(char *A)
  327. {
  328.    char *block;
  330.    block = string_create_progression(108 + string_measure(A)); 
  331.    string_update(block, get_sha256(A, string_measure(A)), 32);
  332.    string_update_4(block, 0);
  333.    string_update(block, get_minimal(), 32);
  334.    string_update(block, get_maximal(), 32);
  335.    string_update_4(block, time(0));
  336.    string_update_4(block, 1);
  337.    string_update(block, A, string_measure(A));
  339.    return block;
  340. }
  342. char *block_4479(char *previous, char *A, char *B)
  343. {
  344.    char *block, *tree;
  346.    tree = string_create_progression(64);
  347.    string_update(tree, get_sha256(A, string_measure(A)), 32);
  348.    string_update(tree, get_sha256(B, string_measure(B)), 32);
  350.    block = string_create_progression(108 + string_measure(A) + string_measure(B));
  351.    string_update(block, get_merkle_root(tree, 2), 32);
  352.    string_update_4(block, 0);
  353.    string_update(block, previous, 32);
  354.    string_update(block, get_maximal(), 32);
  355.    string_update_4(block, time(0));
  356.    string_update_4(block, 2);
  357.    string_update(block, A, string_measure(A));
  358.    string_update(block, B, string_measure(B));
  360.    return block;
  361. }
  363. char *transaction_8629(char *lichangli)
  364. {
  365.    char *input_0, *output_0, *progression;
  367.    input_0 = build_input(0, string_create_improper(""), string_create_improper(""), get_minimal());
  368.    output_0 = build_output(lichangli, 100);
  370.    progression = string_create_progression(12 + scan(input_0) + scan(output_0));
  371.    string_update_4(progression, 12 + scan(input_0) + scan(output_0));
  372.    string_update_4(progression, 1);
  373.    string_update_4(progression, 1);
  374.    string_update(progression, input_0, scan(input_0));
  375.    string_update(progression, output_0, scan(output_0));
  377.    return progression;
  378. }
  380. char *transaction_4140(char *lichangli)
  381. {
  382.    char *input_0, *output_0, *progression;
  384.    input_0 = build_input(0, string_create_improper(""), string_create_improper(""), get_minimal());
  385.    output_0 = build_output(lichangli, 100);
  387.    progression = string_create_progression(12 + scan(input_0) + scan(output_0));
  388.    string_update_4(progression, 12 + scan(input_0) + scan(output_0));
  389.    string_update_4(progression, 1);
  390.    string_update_4(progression, 1);
  391.    string_update(progression, input_0, scan(input_0));
  392.    string_update(progression, output_0, scan(output_0));
  394.    return progression;
  395. }

4.4.3 示例数据写入调用

完成了示例数据的写入, 就方便后面开发读取和验证的部分的代码的测试了.

  1. int main(int count, char **arguments)
  2. {
  3.    ltc_mp = tfm_desc;
  4.    register_prng(&sprng_desc);
  5.    register_hash(&sha256_desc);
  7.    char *A, *B, *C, *BLOCK_A, *BLOCK_B;
  8.    char *_6301, *_1604, *_1215;
  9.    char *buffer;
  10.    int length;
  11.    char *panpeng_address, *panpeng_public, *lichangli_address, *lichangli_public, *lichangli_private;
  13.    _6301 = "MEwDAgcAAgEgAiEAy4Dqak+QdoTjLOneFcw45XLVvRo1pxlurO7CdnSiEmkCIEHKqUkf236XXyybfJWX8dhvHKJXHwJ2TKJ6f2J78OIiMEwDAgcAAgEgAiEAy
  14. 4Dqak+QdoTjLOneFcw45XLVvRo1pxlurO7CdnSiEmkCIEHKqUkf236XXyybfJWX8dhvHKJXHwJ2TKJ6f2J78OIi";   
  15.    _1604 = "MEwDAgcAAgEgAiB/XlZGVRCrgg1QoZpLXP25dBxfE+l53GcrQT+rnOyMtQIhAPjOmLLKCkZeuk378KlQCLXGYcx3ZZNpYt2xqPTS6BC/";
  16.    _1215 = "MG8DAgeAAgEgAiB/XlZGVRCrgg1QoZpLXP25dBxfE+l53GcrQT+rnOyMtQIhAPjOmLLKCkZeuk378KlQCLXGYcx3ZZNpYt2xqPTS6BC/AiEAuUgmCNAsw2ElO
  17. 5hxpvAzJpKcdSuyiHV84R2jTPFVu7o=";
  19.    buffer = malloc(1000);
  21.    length = 1000;
  22.    base64_decode(_6301, strlen(_6301), buffer, &length);
  23.    panpeng_public = string_create(buffer, length);
  25.    length = 1000;
  26.    base64_decode(_1604, strlen(_1604), buffer, &length);
  27.    lichangli_public = string_create(buffer, length);
  29.    length = 1000;
  30.    base64_decode(_1215, strlen(_1215), buffer, &length);
  31.    lichangli_private = string_create(buffer, length);
  33.    panpeng_address = string_create(get_md5(panpeng_public, 32), 16);
  34.    lichangli_address = string_create(get_md5(lichangli_public, 32), 16);
  36.    A = transaction_8629(lichangli_address);
  37.    B = transaction_4140(lichangli_address);
  38.    C = transaction_7159(1, lichangli_public, get_signature(A, lichangli_private), get_sha256(A, string_measure(A)), lichangli_address
  39. , panpeng_address);
  41.    BLOCK_A = block_3930(A);
  42.    BLOCK_B = block_4479(get_sha256(BLOCK_A, string_measure(BLOCK_A)), B, C);
  44.    write(1, BLOCK_B, string_measure(BLOCK_B));
  45. }

5. 区块节点读取验证与挖矿

5.1 merkle tree 说明

Hash的计算简要示意
image_1btodkb4qm17lf2fj1q96gr13.png-52.9kB
交易的hash计算与区块简要示意
image_1btodfhca5dr15cg1s2760lm919.png-41.9kB

5.1.1 递归函数定义

递归计算merkle root
先计算单个.
然后计算奇数的hash,
计算偶数的hash

  1.   pseudo code, author by Lijun
  2.   merkle_root(arr[])
  3.   if(count(arr[]) ==1 ) return arr[0];
  4.   if(count(arr[]) %2 ) 
  5.       return sha256(merkle_root(arr[0,n-2]), arr[n-1])
  6.   else
  7.       return  shar256(merkle_root(arr[0,n/2-1]), merkle_root(arr[n/2, n-1]);

只有一个交易,merkle root就是对这个交易的hash.

  • get_merkle_root(X) = X
  • get_merkle_root(X0 , X1 ， …… ， X2n ) = get_merkle_root(X0 ,X1 ,…… ，X2n,X2n)
  • get_merkle_root(X0 , X1 ， …… ， X2n-1 ) = get_merkle_root(SHA256(X0+X1), SHA256(X2+X3) ……)
  1.  function(x) {
  2.     if (count(x) == 1 ) return x;
  3.     if (count(x) %2) x.push[x, (
  4.  }

5.1.2 php递归实现代码

  1. <?php
  3. function get_lines_file($file)
  4. {
  5.    $result = array();
  7.    $contents = file_get_contents($file);
  8.    $contents = explode(chr(10), $contents); //用换行符分割
  10.    // linux 放10, windows会放13,10作为换行,所以删掉13
  11.    foreach ($contents as $item) {
  12.       $item = str_replace(chr(13), '', $item); // 去掉char13
  13.       if (strlen($item) > 0)
  14.          array_push($result, $item);
  15.    }
  17.    return $result;
  18. }
  20. /*  生成hash. 可以输出存到 文件里.
  21.     $digests = array();
  22.     foreach(range(1,100) as $number)
  23.         $digests[] = hash('sha256', rand());
  24. */
  26. $x = get_lines_file('digests.txt');   
  27. var_dump(get_Merkle_root($x));
  29. function get_Merkle_root($digests)
  30. {
  31.    if (count($digests) == 1) {
  33.       echo sprintf('Case #1: %d%c', count($digests), 10);
  35.       return $digests[0];
  36.    }
  38.    if (count($digests) % 2) {  // 奇数
  40.       echo sprintf('Case #2: %d%c', count($digests), 10);
  42.       $item = $digests[count($digests) - 1];
  43.       array_push($digests, $item);   // push, 把最后1个item复制
  45.       return get_Merkle_root($digests);
  46.    }
  48.    echo sprintf('Case #3: %d%c', count($digests), 10);
  50.    for ($i = 0, $s = count($digests) / 2; $i < $s; $i++) {
  51.       $a = array_shift($digests);   // 从左侧移出
  52.       $b = array_shift($digests);   // 组成一对计算hash.
  53.       array_push($digests, hash('sha256', $a . $b));  //从右侧插入
  54.    }
  56.    return get_Merkle_root($digests);
  58.    /* 另外一种方法, 新建一个数组reduced存放
  59.    $i = 0;
  60.    while($i < count($digests)){
  61.      $merged= sprintf('%s%s',$digests[i[,$digests[i+1]);
  62.      array_push($reduced, hash('sha256',$merged));
  63.      $i += 2;
  64.    }
  65.    return get_Merkle_root($reduced);
  66.    */
  68. }

digests.txt的内容是100个随机数的hash值, 每行一个hash值.

  1. $ head -3 digests.txt                                                                                                                       
  2. c5c77f852587da8a14d163e9be251c79590ac1354da79397b44b7e23e55d7470
  3. 4247c422e39497fc67e527dffe0ccbcd19dc9be0bd12ed2c9bc78ae4f64ce369
  4. e9f07edbdbdc7403a93903840a096944b7194d38a73b497531fb65a56541cab7

5.2 区块节点读取说明

创造节点之后, 读取区块相关内容信息, 并进行验证, 确认都是正确的.

再次回顾下数据结构:

Head的长度固定, 所以不需要保存长度. 这里设计为104

字段说明 current nounce previous target time
说明 BODY的sha256输出,当前block的ID 挖矿难度 前个区块的ID 越大难度越小 ?时间
长度(字节) 32 4 32 32 4

Transaction 旧设计

字段名 A B Input* C Output*
说明 总长度 所有输入长度 输入 所有output长度 多个输出
长度(字节) 4 4 B 4 C

Transaction 新设计

字段名 A B C Input* Output*
说明 总长度(含自己) 输入个数 输出个数 输入列表 输出列表
长度(字节) 4 4 4 B C

Head 后面跟多个Transaction. 其中第1个Transaction是创始交易, 用于矿工奖励.

Transaction
为了方便, 将上表中的 B, Input*, C, Output* 统一表示为后继内容Content.

字段名 Head Transaction#1 Transaction#2 T#3 ...
说明 头部 总长度A和后继内容 总长度A和后继内容 总长度A和后继内容 ...
结构 Head A,Content A,Content A,Content ...
长度(字节) 104 A A A ...

5.2.1 基于字节的移动来读取内容

取得区块的生字节后, 可以通过指针来回移动, 获取相关内容. 指针到达的位置就是整数int长度的位置, 取*就可以得到其长度.

x+104, // 到达body,第一个交易.
x +104 +(*) // 达到第2个交易.
x +104 +(*) + (*) // 达到第2个交易.

C语言实现:

  1. x = x + 104;
  2. x = x + (*x);
  3. x = x + (*x);

5.2.2 指针移动获得区块的不同变量

回顾Input的结构:
INPUT := A, INDEX, B, PUBLIC, C, SIGNATURE, TRANSACTION

通过指针移动获取相应变量地址

  1. unsigned *A, *B, *C
  2. A = input
  3. B = input + 8
  4. C = input + 12 + B

5.2.3 对区块里有多少交易进行计数

  1. #include "stdio.h"
  2. #include "stdlib.h"
  3. #include "string.h"
  5. // 这里加了length存 读取出文件内容的长度.
  6. unsigned char *get_file(char *path, long *length) {
  8.     FILE *file;
  9.     unsigned char *contents;
  11.     file = fopen(path, "r+");
  12.     fseek(file, 0, SEEK_END);
  13.     *length = ftell(file);
  14.     fseek(file, 0, SEEK_SET);
  16.     contents = malloc((size_t)*length);
  17.     fread(contents, 1, (size_t)*length, file);
  18.     fclose(file);
  20.     return contents;
  21. }
  23. unsigned int slice(unsigned char *cursor, unsigned int length)
  24. {
  25.    unsigned char *limit;
  26.    unsigned int *X;
  28.    unsigned int count;
  30.    limit = cursor + length;  // 尾部
  31.    cursor += 104;
  32.    count = 0;
  34.    while (cursor < limit) {
  36.       X = (unsigned int *)cursor;  //指针类型转换
  37.       cursor += *X;   // 跳到下个交易
  38.       count++;
  39.    }
  41.    return count;
  42. }
  44. int main(int count, char **arguments)
  45. {
  46.    unsigned char *block;
  47.    unsigned int length;
  48.    block = get_file(arguments[1], &length);
  49.    printf("%d%c", slice(block, length), 10);
  50. }

5.2.2 构造链表来读取交易

image_1btodtl5s5t219q3dqaauf1gkl20.png-222kB

在上一个slice的基础上, 一边遍历,一边分配空间, 同时创造linklist来指向内容空间.

  1. unsigned int slice(unsigned char *cursor, unsigned int length)
  2. {
  3.    unsigned char *limit, *transaction;
  4.    unsigned int *X;
  5.    void *list, *link;
  7.    unsigned int count;
  9.    limit = cursor + length;  // 尾部
  10.    cursor += 104;
  11.    count = 0;
  13.    while (cursor < limit) {
  15.       X = (unsigned int *)cursor;  //指针类型转换
  16.       transaction = malloc(*X + 4)  + 4; //获取新分配的内容空间的交易内容地址起始位置
  17.       memcpy(transaction, cursor, *X); //保存内容, 长度为*X,即交易长度
  18.       memcpy(transaction-4, X, 4);  // 保存内容的长度. 
  19.       cursor += *X; 
  20.       count++;
  22.       // 相当2个4字节指针,前一个装内容地址, 后一个装后list的地址
  23.       // 这是一种比较粗糙的方式来构造linklist, 后面会介绍通过函数来构造.
  24.       link = malloc(8);
  25.       memcpy(link, transaction, 4);
  26.       memcpy(link + 4, list, 4); 
  28.       list = link;
  29.    }
  31.    return count;
  32. }

5.3 区块节点存储的读取实现

5.3.1 区块链结构存储的处理程序规划

  1. storage.add_block( $storage, $substance)
  2. storage.remove_block($storage, $identify)
  3. storage.get_block($storage, $identify)
  4. storage.load($storage, $identify)     // 放内存 
  5. storage.unload($storage, $identify)  // 从内存中卸载.  放硬盘上 缓存
  6. storage.get_transaction($storage, $identify);
  7. //
  8. int *storage_load    read_file() get_file() 
  9. int *storage_unload     write_file(path, substance, length)
  10. char *storage_get_block

可以用heap list vector or tree 来落实上面的函数, 在效率上会有差别, 但是效果一样.

5.3.2 如果是网络读取,则tcp接收区块.

1) 阅读 108个字节, 保存valence为Y
2) 读 4个字节, 保存为X
3) 读 X 个字节
4) 用副函数来确认此交易格式
5) 递归向 步骤2 一共 Y次
6) 做验证. (格式已经确认)

5.3.3 区块节点存储设计开发详细说明

规划设计:
Storage 的结构
// 容量, 创始的指针, 文件路径的指针, 区块数量, 区块1, 2...
// CAPACITY, GENESIS, PATH, VALENCE, RECORD #1, RECORD #2, ...
// 4, 4, 4, 4, 4 (block#1 pointer), 4 (block#2 pointer)..

block# pointer ---> RECORD
// RECORD := IDENTITY, LENGTH, SUBSTANCE

/*
CAPACITY, GENESIS, PATH, VALENCE, RECORD #1, RECORD #2, ...
RECORD := IDENTITY, LENGTH, SUBSTANCE
*/

源代码来自15节课 storage.c 

  1. char *storage_get(char *storage, char *identity, int *length)
  2. {
  3.    char *_2250, **_9000, **_4708;
  4.    int *_5756;
  5.    char **cursor, **boundary;
  6.    int *valence;
  8.    char **_0000;
  10.    valence = (int *) (storage + 12);
  11.    cursor = (char **) (storage + 16);
  12.    boundary = (char **) (storage + 16 + *valence * 4);
  14.    while (cursor < boundary) {
  16.       _0000 = (char **) cursor;
  17.       _9000 = (char **) *_0000;
  18.       _5756 = (int *) (*_0000 + 4);
  19.       _4708 = (char **) (*_0000 + 8);
  21.       printf("while: %d%c", *_5756, 10);
  23.       if (memcmp(identity, *_9000, 32) == 0) {
  25.          printf("match was found%c", 10);
  27.          _2250 = malloc(*length = *_5756);
  28.          memcpy(_2250, *_4708, *_5756);
  30.          return _2250;
  31.       }
  33.       cursor++;
  34.    }
  36.    return 0;
  37. }
  39. char *storage_create(int capacity, char *genesis, char *path)
  40. {
  41.    char *_9877, *_1767;
  42.    char **_2789;
  43.    int *_1046;
  45.    _9877 = malloc(16 + 4 * capacity);
  47.    _1046 = (int *) _9877;
  48.    *_1046 = capacity;
  50.    _1767 = malloc(32);
  51.    memcpy(_1767, genesis, 32);
  52.    _2789 = (char **) (_9877 + 4);
  53.    *_2789 = _1767;
  55.    _1767 = malloc(strlen(path));
  56.    strcpy(_1767, path);
  57.    _2789 = (char **) (_9877 + 8);
  58.    *_2789 = _1767;
  60.    _1046 = (int *) (_9877 + 12);
  61.    *_1046 = 0;
  63.    return _9877;
  64. }
  66. void storage_add(char *storage, char *identity, char *substance, int length)
  67. {
  68.    char **_9646, **_8035;
  69.    int *capacity, *valence, *_4683;
  70.    char *_7990, *record;
  72.    valence = (int *) (storage + 12);
  73.    _9646 = (char **) (storage + 16 + *valence * 4);
  75.    char **_1616, **_7413;
  76.    int *_9039;
  78.    record = malloc(12);
  79.    _1616 = (char **) record;
  80.    _9039 = (int *) (record + 4);
  81.    _7413 = (char **) (record + 8);
  83.    *_1616 = malloc(32);
  84.    memcpy(*_1616, identity, 32);
  85.    *_9039 = length;
  86.    *_7413 = malloc(32);
  87.    memcpy(*_7413, substance, length);
  89.    *_9646 = record;
  90.    *valence += 1;
  91. }

调用链区块节点存储 

  1. int main(int count, char **arguments)
  2. {
  3.    ltc_mp = tfm_desc;
  4.    register_prng(&sprng_desc);
  5.    register_hash(&sha256_desc);
  7.    char *storage, *substance;
  8.    int *valence, length;
  10.    storage = storage_create(400, get_minimal(), "/tmp/blocks");
  11.    valence = (int *) (storage + 12);
  12.    printf("valence: %d%c", *valence, 10);
  14.    storage_add(storage, get_minimal(), "hello", 6);
  15.    valence = (int *) (storage + 12);
  16.    printf("valence: %d%c", *valence, 10);
  18.    storage_add(storage, get_maximal(), "goodbye", 8);
  19.    valence = (int *) (storage + 12);
  20.    printf("valence: %d%c", *valence, 10);
  22.    int *_3895;
  23.    int *_9394;
  24.    char **_8900;
  26.    _3895 = (int *) (storage);
  27.    printf("inspection: %d%c", *_3895, 10);
  28.    _3895 = (int *) (storage + 4);
  29.    printf("inspection: %d%c", *_3895, 10);
  30.    _3895 = (int *) (storage + 8);
  31.    printf("inspection: %d%c", *_3895, 10);
  32.    _3895 = (int *) (storage + 12);
  33.    printf("inspection: %d%c", *_3895, 10);
  34.    _3895 = (int *) (storage + 16);
  35.    printf("inspection: %d%c", *_3895, 10);
  36.    _3895 = (int *) (storage + 20);
  37.    printf("inspection: %d%c", *_3895, 10);
  38.    _3895 = (int *) (storage + 24);
  39.    printf("inspection: %d%c", *_3895, 10);
  40.    _3895 = (int *) (storage + 28);
  41.    printf("inspection: %d%c", *_3895, 10);
  43.    _8900 = (char **) (storage + 20);
  44.    _9394 = (int *) (*_8900 + 4);
  45.    printf("inspection: %d%c", *_9394, 10);
  47.    substance = storage_get(storage, get_minimal(), &length);
  48.    printf("storage_get(): %d%c", length, 10);
  49.    printf("storage_get(): %s%c", substance, 10);
  50.    substance = storage_get(storage, get_maximal(), &length);
  51.    printf("storage_get(): %d%c", length, 10);
  52.    printf("storage_get(): %s%c", substance, 10);
  53. }

5.3.4 改进:存储改为hash实现

如果区块链的存储要更改,改为效率更高一些, 可以改为用hashtable.
(组成: 256个bucket, 指针列表, 元数据.) 通过hash找到对应bucket, 搜索时为O(lg(n))的复杂度.
image_1bv4ha57l1f6r4sm18j81140ogs9.png-671.1kB

5.4 区块节点验证说明

创造节点之后,
* 读取区块相关内容信息, 并进行验证, 确认都是正确的.
* 验证第2个以上的交易(input, output, transaction balance),
* 然后验证第一个交易, 还有头部.

验证:
(1) 格式
(2) 输入: 此输入是否存在; 输入的签名是否有校验
(3) 输出:
(4) 交易平衡: 输入是否多于或者等于输出的总额?
(5) 第一个交易
(6) 头部 交易的摘要是否正确? 劳动证明是否正确?

5.4.1 劳动证明与挖矿规则

劳动证明是看有没有做挖掘的过程, 挖掘的目的是为了防止一个人短时间制造大量的空区块, 也为了维持竞争性.
不同的网络上的节点, 每个区块的生产的过程, 相当于比赛的一局. 胜利者获利,其他人没有获得.

矿池联合挖, 自己制定一个规则, 矿主决定怎么分配利润.

大多数规则:
一个成员要是挖掘了接近正确的结果, 虽然无效, 也上报,
矿池主人根据劳动的难度的工作证明, 按照比例分配.
如A,B,C 分别挖掘了4,6,10的难度的工作, 则按此比例进行分配货币.
除此之外, 矿池主人还会再扣一些类似赋税.

节点与挖矿程序的沟通

BTC官方节点 和 挖矿程序 是通过 http 和 json-rpc 进行沟通, 效率比较低.
计算机更擅长生字节的处理. 需要转换.
好多矿池的程序修改或写了自己的节点程序, 直接用TCP 沟通.

5.4.2 区块的遍历与验证

5.4.2.1 验证过程

验证身部Body

要检查验证input, output, 还有transaction的正确性.

  1. 每一个input内, 查找 transaction, index 是否存在
  2. 每一个input内, 拿public, signature 和赌赢的output的address, 然后运行 ECC verify, 看true or false, false表示失败
  3. 检查 sigma intput >= sigma output , 记录剩余
  4. 检查 sigma 剩余 >= coinbase 的小费
  5. 验证头部
验证头部Head
  1. 检查时间: 必须大于上7个区块的平均时间, 为了保持区块链的时间在不断往上升.
  2. 检查target是否少于或者等于协议规定的target, target越小,难度越大
  3. 计算整个头的SHA256是否少于target, 然后检查 merkle tree
程序实现函数规划
  1. check_transaction($substance, $length)
  2. check_input($substance, $length)
  3. check_output($substance, $length)

5.4.2.2 程序实现

  1. /* 数链表的节点个数 */
  2. int count_list(void *cursor)
  3. {
  4.     int count;
  5.     void *Y;
  7.     count = 0;
  9.     while (cursor != 0)
  10.     {
  11.         count++;
  12.         Y = cursor + 4;
  13. //        cursor = (void *) *Y;
  14.     }
  16.     return count;
  17. }
  19. // 用于构造一对, 这里可以用于构造2个指针对, 作为链表的节点.
  20. void *build_pair(void *left, void *right)
  21. {
  22.     void *pair;
  24.     pair = malloc(8);
  25.     memcpy(pair, &left, 4);
  26.     memcpy(pair + 4, &right, 4);
  28.     return pair;
  29. }
  31. /* 对于指针指向字符存长度位置的正当字符串(pascal string), 返回字符串的长度, 也可用于区块数据大小的读取. */
  32. int scan(unsigned char *source) // 返回大小
  33. {
  34.     int *size;
  36.     size = (int *) source;
  38.     return *size;
  39. }
  40. /* 对于指针指向字符内容起始位置的正当字符串(pascal string), 返回字符串的长度,  也可用于区块数据大小的读取. */
  41. int measure(char *source)
  42. {
  43.     int *length;
  45.     length = (int *) (source - 4);
  47.     return *length;
  48. }
  49. /* 字符串分2种, 
  50.     一种是\0结尾, 不记录长度. 不能存\0, 叫做非正当字符串 improper (c string) 
  51.     一种记录长度, 可以存任意字符串. 叫做正当字符串 proper (pascal string) 
  52.     其中int整数存储长度, 本身占用4个字节.
  53.     下面是后一种  
  54. */
  55. /* 构造包含自己长度的字符串, [length,string_content] */
  56. unsigned char *build(unsigned char *source, int length) 
  57. {
  58.     unsigned char *destination;
  60.     destination = malloc((size_t)length + 4); //比长度大4的空间
  61.     memcpy(destination, &length, 4);  // 放长度
  62.     memcpy(destination + 4, source, length);  //放内容
  64.     return destination;
  65. }
  67. unsigned char *get_file(char *path, long *length) {
  69.     FILE *file;
  70.     unsigned char *contents;
  72.     file = fopen(path, "r+");
  73.     fseek(file, 0, SEEK_END);
  74.     *length = ftell(file);
  75.     fseek(file, 0, SEEK_SET);
  77.     contents = malloc((size_t)*length);
  78.     fread(contents, 1, (size_t)*length, file);
  79.     fclose(file);
  81.     return contents;
  82. }
  84. /* Slice 函数用于把一个区块block切成交易.
  85.  实际内存过程展示: 
  86.   形成head元素:
  87.     head_pointer
  88.       | 
  89.      [length, head_content]
  91.   形成链表的第1个节点.
  92.   list_pointer --> [ head_pointer, \0]
  93.                     |
  94.                    [head]
  96.   进入while循环后, 指向block的指针依次按照transaction的大小向后移动. 
  97.   添加当前读取到的交易transaction到内存中, 
  98.   然后添加第2个链表节点,节点中的指针指向 transaction.
  99.     [head, transaction#1, transaction#2, .... ]
  100.   len:104 |len,content   | len, content|...
  101.           ^
  102.         cursor  ---> 指针按照交易大小顺序移动 
  104.   读取并构建交易到内存中, 同时构建指针链表保存交易地址       
  105.   list_pointer --> [head_pointer, list_pointer] --> [head_pointer, \0]
  106.                     |                               |
  107.                    [transaction]                   [head]
  108.   第3个及以后的transaction以及链表依次实现.
  110. */
  111. // 返回一个指针链表的尾部. 链表中存的是指向交易和head的指针.
  112. void *slice(unsigned char *cursor, long length)
  113. {
  114.     unsigned char *limit, *head;
  115.     void *list;
  117.     limit = cursor + length;
  118.     list = 0;
  120.     head = build(cursor, 104);  // 内存中构造head节点
  121.     printf("head pointer: %d%c", (int)head, 10);
  123.     list = build_pair(head, list); // 记录head指针,list指针为pair. 形成链表的第1个节点.   
  124.     printf("list pointer: %d%c", (int)list, 10);
  126.     cursor += 104;
  128.     // 
  129.     while (cursor < limit) {
  130.         //内存中构造transaction.
  131.         unsigned char *x = build(cursor, scan(cursor)); 
  133.         printf("transaction pointer: %d%c", (int)x, 10); 
  134.         //增加链表节点, 
  135.         list = build_pair(x, list);
  136.         cursor += scan(cursor);
  137.     }
  139.     return list;
  140. }
  142. /*
  143. list[0] -> HEAD
  144. list[1] -> COINBASE
  145. list[2] -> TRANSACTION #2
  146. list[3] -> TRANSACTION #3...
  147. */
  149. // TRANSACTION := A, B, C, INPUT*, OUTPUT*
  150. // 这里的Transaction的定义与前面不一致了! 
  152. // 得到输出的交易金额
  153. uint64_t get_output_amount(unsigned char *output)
  154. {
  155.     // A B ADDRESS AMOUNT
  157.     int *B;
  158.     uint64_t amount;  //交易金额数量.
  160.     B = (int *) (output + 4);
  162.     memcpy(&amount, output + 8 + *B, 8);
  163.     return amount;
  164. }
  166. /*验证一个交易中的所有input,ouput的数量. */
  167. int verify(unsigned char *transaction)
  168. {
  169.     int *A, *B, *C;
  170.     unsigned char *cursor;
  171.     int count;
  173.     A = (int *) transaction;
  174.     B = (int *) (transaction + 4);
  175.     C = (int *) (transaction + 8);
  177.     printf("%d%c", *A, 10);
  178.     printf("%d%c", *B, 10);
  179.     printf("%d%c", *C, 10);
  181.     //8字节的整数定义.
  182.     uint64_t input_total, output_total = 0;  // 用于记录input,output个数.
  184.     cursor = transaction + 12;
  185.     count = *B;
  187. /*  查找输入的数量, 可以查看数据库??
  188.    while (count--) {
  189.       input_total += get_input_total(cursor); //得到输入的总数量.? 
  190.       cursor += scan(cursor);
  191.    }
  192. */
  194.     while (count--)
  195.         cursor += scan(cursor);
  197.     count = *C;
  199.     while (count--) {
  200.         output_total += get_output_amount(cursor); //得到交易金额
  201.         cursor += scan(cursor);
  202.     }
  204.     printf("number of outputs: %d%c", *C, 10);
  205.     printf("volume of outputs: %d%c", (int) output_total, 10); //交易金额
  207.     return 0;
  208. }
  210. int main(int count, char **arguments)
  211. {
  212.     unsigned char *block, *data;
  213.     long length;
  214.     void *list;
  215.     char *a;
  217.     block = get_file(arguments[1], &length);
  218.     list = slice(block, length);  // 分割block文件, 分配空间并存指针到list中.
  220.     /*  
  221.     list += 4;
  222.     */
  224.     while ((int)list != 0 ) {
  225.         data = (unsigned char *) *((int *) list); // 得到交易地址
  226.         printf("value: %d%c", (int)data, 10);
  227.         list = (void *)*((int *) (list + 4));   //下一个链表节点.
  228.         printf("list: %d%c", (int)list, 10);
  229.     }
  231.     // verify(list + 4);
  232. }

5.5 挖矿

5.5.1 挖矿代码示例

源代码来自15节课 mining.c
还可以继续优化, 去除函数调用,直接sha256, 去除打印

  1. char *get_target(int count)
  2. {
  3.    char *_2666;
  5.    _2666 = malloc(32);
  6.    memset(_2666, 0, count);
  7.    memset(_2666 + count, 255, 32 - count);
  9.    return _2666;
  10. }
  12. int main(int count, char **arguments)
  13. {
  14.   // mining.
  15.    ltc_mp = tfm_desc;
  16.    register_prng(&sprng_desc);
  17.    register_hash(&sha256_desc);
  19.    char *block, *identity;
  20.    int length;
  22.    block = read_file(arguments[1], &length);
  24.    printf("target is: ");
  25.    print_digest(block + 68);
  26.    printf("----%c", 10);
  28.    int *_8425 = (int *) (block + 32);
  30.    while (1) {
  32.       identity = get_sha256(block, 108);
  34. if ((*_8425) % 144 == 0) {
  35.       printf("%d: ", *_8425);
  36.       print_digest(identity);
  37. }
  39.       if (memcmp(identity, block + 68, 32) < 0) {
  41.          printf("solution found: ");
  42.          print_digest(identity);
  44.          write_file(arguments[1], block, length);
  45.          exit(0);
  46.       }
  48.       free(identity);
  49.       *_8425 += 1;
  50.    }
  51. }

设置block的的难度.

  1. /*  set difficulty.
  2.    char *substance;
  3.    int length;
  5.    substance = read_file("1.block", &length);
  6.    memcpy(substance + 68, get_target(3), 32);
  7.    memset(substance + 32, 0, 4);
  8.    write_file("0.block", substance, length);
  9. */

5.5.2 挖矿过程和结果展示

  1. $ ./mining 1.block                                                                                                                          
  2. target is: 00ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
  3. ----
  4. 0: 09f59a9028317e4a157d5db7fee3e4ed1f837f0c84a37c792bc37db3a4073a0e
  5. 144: 84e991a6fbdc1c2340eff67bd4c2eb83bed96d8a2c410aa28bd0c1bfe3a999ea
  6. 288: 4f6471e7715489020f2fd01a290677204bea470b28c28d6bb3030c11d604cea0
  7. 432: 8e08457bd3f00f4bb246af83b42ea3c16616117a125b360cc82552bd0bb88b14
  8. solution found: 00858823157712677db364008b1b41339229497e6a49b343e664d1753c8ce47e

6. 应用和节点程序之间协议

7. 节点之间沟通

7.1 Sockets

7.1.1 Sockets 说明

C语言套接字.
建议把相关函数及参数使用记录下来.
image_1bv6uljjv1i3b1ilsip1404g6a9.png-74.9kB

image_1bto7u8pg1ot5qlgdi1cq71husg.png-23.9kB

  1. 系统呼叫：open(1),close(1),read(1),write(1)。
  2. 套接字socket：几乎所有经过网络的过程都经过socket。

  3. 每一个网络编程中，都包括连接者和被动连接者（监听者）。
    *问题：一个监听者在单线程的情况下，如何监听多个连接者？
    其中一个解决方法是排队。在监听一个连接着的时候，其他连接者被中断，排队等待。
    三个方式实现并行处理：创建新的进程、创建新的线程、使用两个特殊的系统呼叫select(2)或者poll(2)。

    • socket：制造一个新的套接字。三个参数，socket(family,type,protocol).
  1.          family：家族，family的取值为2，表示互联网。
  2.          type： 类型，取值为1时表示tcp，取值为2时表示udp。tcp更安全，但是udp更快。游戏和网络视频中，一般使用udp，因为更在乎速度。一般 上午数据使用tcp，因为更在乎安全。                       我们课程使用udp做一个钱包，很快，但是可能会丢包。使用udp再使用udp检查丢包，相当于是一个tcp，但是时间成本远低于tcp。
  3.                udp没有连接的概念，不需要使用connect函数。
  4.          protocol：协议，取值为0。
  5.          domain socket：区域套接，不能上网的套接。
  6.          netlink socket：网链套接，也不能上网，只有LInux存在，为了让程序和驱动器沟通。
  7.          INET socket：即internet socket，互联网套接，我们正在使用的。
  1.           其中，x=socket（family，type，protocol）。
  2.           呼叫connect时，系统会卡住等待连接，所以每次做connect时，需要做多线程。这样当系统等待连接卡住的时候，其他线程不会被影响。
  3.          y=connect（x，目标，目标的大小）。表示是否连接成功。

7.1.2 Sockets 实现

7.1.2.1 连接者程序(不添加参数)

1.连接者程序(不添加参数)
一端使用nc -l 127.0.0.1 6004启动监听程序，另一端使用tcc -run MyConnect.c 发送消息，则可以被监听到。

  1. #include "stdio.h"
  2. #include "sys/socket.h"
  3. #include "arpa/inet.h"
  5. void main()
  6. {
  7.   int s ;
  8.   struct sockaddr_in a;
  10.   s = socket(2,1,0);//2表示互联网，1表示tcp，0表示协议
  11.   if (s == -1)//s== -1表示套接字失败
  12.     exit(1);
  14.   a.sin_family = 2;
  15.   a.sin_port = htons(6004);
  16.   a.sin_addr.s_addr = inet_addr("127.0.0.1");
  18.   int f = connect(s, (struct sockaddr *) &a, sizeof a);//第一个参数是套接字的结果，第二个参数是连接目标，第三个参数是连接目标的大小。
  19.   if (f == -1)
  20.     exit(2);
  21.   send(s,"hello ",6,0);//加空格，长度为6
  22.   send(s,"world ",6,0);
  23. }

7.1.2.2 连接者程序(带参数)

    一端使用nc -l 127.0.0.1 6004启动监听程序，另一端使用tcc -run MyConnect.c 127.0.0.1 6004 发送消息，则可以被监听到。

  1. #include "stdio.h"   //printf() fopen() fread() fwrite() fclose()
  2. #include "stdlib.h"  //malloc(oc() free()
  3. #include "string.h"  //strlen() strtok()
  4. #include "sys/socket.h"   //socket
  5. #include "arpa/inet.h"    //socket intnet
  7. int main (int count, char **arguments)
  8. {
  9.   int s ;
  10.   struct sockaddr_in a;
  11.   if (count != 3){  //函数名也作为一个参数，所以一共需要三个参数。
  12.     printf("error: there must be three arguments%c",10);
  13.     exit(3);
  14.   }
  16.   s = socket(2,1,0);
  17.   if (s == -1){//s==-1,unsuccessful
  18.     exit(1);
  19.   }
  21.   a.sin_family = 2;
  22.   a.sin_port = htons(atoi(arguments[2]));  //atoi把参数中的字符类型转换为整型
  23.   a.sin_addr.s_addr = inet_addr(arguments[1]);  //两个点，是属性中的属性
  25.   int f = connect(s,(struct sockaddr *) &a, sizeof a);
  26.   if (f == -1)
  27.     exit(2);
  29.   send(s,"hello ",6,0);
  30.   send(s,"world ",6,0);
  31. }

7.1.2.3 监听者程序

一端使用tcc -run MyListen.c 6006 运行监听者程序，另一端使用nc 127.0.0.1 6006 启动连接，则连接者的输入可以被监听者监听到。

  1. #include "stdio.h"
  2. #include "sys/socket.h"
  3. #include "arpa/inet.h"
  5. int main(int count, char **arguments)
  6. {
  7.   int s,error,length,opponent;
  8.   struct sockaddr_in a;
  9.   char buffer[1000];  //长度为1000的缓存，如果发送消息的长度超过1000，则被分割为很多个长度为1000的块。
  11.   s = socket(2,1,0);  
  12.   if (s == -1)
  13.     exit(1);
  15.   a.sin_family = 2;
  16.   a.sin_port = htons(atoi(arguments[1]));
  17.   a.sin_addr.s_addr = inet_addr("0.0.0.0");  //0.0.0.0表示可以监听任何地址。127.0.0.1表示只可以监听自己的地址。
  19.   error = bind(s,(struct sockaddr *) &a,sizeof a);   //bind函数的目的是设置
  20.   if (error == -1)
  21.   {
  22.     exit(1);
  23.   }
  24.   //listen函数的目的是开始监听
  25.   error = listen(s,1024);   //1024表示允许监听的连接者的树木的最大值。第一个被监听，之后的1023个排队等待，第1025个被立即拒绝。
  26.   if (error == -1)
  27.   {
  28.     exit(1);
  29.   }
  30.   //accept被呼叫之后，连接才会被收到
  31.   opponent = accept(s,0,0);  //后面两个参数表示对方的地址和地址长度，0,0表示不关心对方的地址
  32.   if (opponent == -1)
  33.   {
  34.     exit(1);
  35.   }
  36.   while(1)  //不断的循环，接听到一句话之后，依然继续链接，而不会立刻断开。
  37.   {
  38.      memset(buffer,0,1000);   
  39. //使用缓冲之前，必须把之前的内容职位0，memset（buffer,0，1000）函数赋值为0
  40. //因为c语言新申请到的内存不是空的，是之前的垃圾信息
  41.      length = recv(opponent, buffer, 1000, 0);
  43.      handle();
  45.      if (length == -1 || length == 0)  //如果length的值为-1或者0的时候，则链接已经断开
  46.     {
  47.       break;
  48.     }
  49.     printf("%s",buffer);
  50.   }
  51. }
  53. void handle()
  54. {
  55. // 商业逻辑处理过程.
  56. }

7.2 有限状态机 finite-state machine

7.2.1 php的简易示例代码和运行结果

通过php示例代码和运行过程展示来了解有限状态机的机制.

  1. $ cat 1-listen.php                                                                                                                  
  2. <?php
  3. /*  示例代码有限状态机设计:
  4.    array(5410, $accumulation)
  5.    array(9694, $result)
  6. */
  8. error_reporting(E_ALL);   //加上这行代码就会汇报任何错误.
  10. $input = "This is the fourteenth session of the blockchain course.";
  11. $situation = array(5410, '');
  13. while (1) {
  15.    $head = substr($input, 0, 1);
  16.    $tail = substr($input, 1);
  18.    $situation = handle_8291($situation, ord($head));
  19.    var_dump($situation);
  21.    if ($situation[0] == 9694)
  22.       break;
  24.    var_dump($input);
  26.    $input = $tail;
  27. }
  29. function handle_8291($situation, $byte)
  30. {
  31.    $situation[1] = $situation[1] . chr($byte);
  33.    if (strlen($situation[1]) >= 24)
  34.       return array(9694);
  36.    return array(5410, $situation[1]);
  37. }
  39. function handle_5884($situation, $byte)
  40. {
  41.    if ($situation[0] == 3786) {
  43.       if ($situation[2] == 0) {
  45.          $integer = unpack_integer(substr($situation[1], strlen($situation[1]) - 4));
  47.          return array(1188, $situation[1], $integer, 4);
  48.       }
  50.       return array(3786, $situation[1] . chr($byte), $situation[2] - 1);
  51.    }
  53.    if ($situation[0] == 1188) {
  55.       if ($situation[2] == 0) {
  57.          return array(5176, $situation[1]);
  58.       }
  60.       if ($situation[3] == 0) {
  62.          $integer = unpack_integer(substr($situation[1], strlen($situation[1]) - 4));
  64.          return array(6458, $situation[1], $situation[2] - 1, $integer);
  65.       }
  67.       return array(1188, $situation[1] . chr($byte), $situation[2], $situation[3] - 1);
  68.    }
  70.    if ($situation[0] == 6458) {
  72.       if ($situation[3] == 0) {
  75.       }
  77.       return array(3933, $situation[1] . chr($byte), $situation[2], 4);
  78.    }
  79. }

运行展示有限状态机的变化过程

  1. $ php 1-listen.php                                                                                                                  
  2. array(2) {
  3.   [0]=>
  4.   int(5410)
  5.   [1]=>
  6.   string(1) "T"
  7. }
  8. string(30) "This is the blockchain course."
  9. array(2) {
  10.   [0]=>
  11.   int(5410)
  12.   [1]=>
  13.   string(2) "Th"
  14. }
  15. string(29) "his is the blockchain course."
  16. array(2) {
  17.   [0]=>
  18.   int(5410)
  19.   [1]=>
  20.   string(3) "Thi"
  21. }
  22. string(28) "is is the blockchain course."
  23. array(2) {
  24.   [0]=>
  25.   int(5410)
  26.   [1]=>
  27.   string(4) "This"
  28. }
  29. string(27) "s is the blockchain course."
  30. array(2) {
  31.   [0]=>
  32.   int(5410)
  33.   [1]=>
  34.   string(5) "This "
  35. }
  36. string(26) " is the blockchain course."
  37. array(2) {
  38.   [0]=>
  39.   int(5410)
  40.   [1]=>
  41.   string(6) "This i"
  42. }
  43. string(25) "is the blockchain course."
  44. array(2) {
  45.   [0]=>
  46.   int(5410)
  47.   [1]=>
  48.   string(7) "This is"
  49. }
  50. string(24) "s the blockchain course."
  51. array(2) {
  52.   [0]=>
  53.   int(5410)
  54.   [1]=>
  55.   string(8) "This is "
  56. }
  57. string(23) " the blockchain course."
  58. array(2) {
  59.   [0]=>
  60.   int(5410)
  61.   [1]=>
  62.   string(9) "This is t"
  63. }
  64. string(22) "the blockchain course."
  65. array(2) {
  66.   [0]=>
  67.   int(5410)
  68.   [1]=>
  69.   string(10) "This is th"
  70. }
  71. string(21) "he blockchain course."
  72. array(2) {
  73.   [0]=>
  74.   int(5410)
  75.   [1]=>
  76.   string(11) "This is the"
  77. }
  78. string(20) "e blockchain course."
  79. array(2) {
  80.   [0]=>
  81.   int(5410)
  82.   [1]=>
  83.   string(12) "This is the "
  84. }
  85. string(19) " blockchain course."
  86. array(2) {
  87.   [0]=>
  88.   int(5410)
  89.   [1]=>
  90.   string(13) "This is the b"
  91. }
  92. string(18) "blockchain course."
  93. array(2) {
  94.   [0]=>
  95.   int(5410)
  96.   [1]=>
  97.   string(14) "This is the bl"
  98. }
  99. string(17) "lockchain course."
  100. array(2) {
  101.   [0]=>
  102.   int(5410)
  103.   [1]=>
  104.   string(15) "This is the blo"
  105. }
  106. string(16) "ockchain course."
  107. array(2) {
  108.   [0]=>
  109.   int(5410)
  110.   [1]=>
  111.   string(16) "This is the bloc"
  112. }
  113. string(15) "ckchain course."
  114. array(2) {
  115.   [0]=>
  116.   int(5410)
  117.   [1]=>
  118.   string(17) "This is the block"
  119. }
  120. string(14) "kchain course."
  121. array(2) {
  122.   [0]=>
  123.   int(5410)
  124.   [1]=>
  125.   string(18) "This is the blockc"
  126. }
  127. string(13) "chain course."
  128. array(2) {
  129.   [0]=>
  130.   int(5410)
  131.   [1]=>
  132.   string(19) "This is the blockch"
  133. }
  134. string(12) "hain course."
  135. array(2) {
  136.   [0]=>
  137.   int(5410)
  138.   [1]=>
  139.   string(20) "This is the blockcha"
  140. }
  141. string(11) "ain course."
  142. array(2) {
  143.   [0]=>
  144.   int(5410)
  145.   [1]=>
  146.   string(21) "This is the blockchai"
  147. }
  148. string(10) "in course."
  149. array(2) {
  150.   [0]=>
  151.   int(5410)
  152.   [1]=>
  153.   string(22) "This is the blockchain"
  154. }
  155. string(9) "n course."
  156. array(2) {
  157.   [0]=>
  158.   int(5410)
  159.   [1]=>
  160.   string(23) "This is the blockchain "
  161. }
  162. string(8) " course."
  163. array(1) {
  164.   [0]=>
  165.   int(9694)
  166. }

7.2.2 php实现接收区块的有限状态机设计

php代码容易理解, 而且翻译成c比较容易. 所以先写php代码.

7.2.2.1 区块读取接收的fsm设计

  1. /*  接收区块交易的有限状态机设计:
  2.         (随机数: 状态;  $buffer: 字节缓存;   $valence: 剩余交易数, count:交易个数;  $length: 剩余读入长度)
  4.    array(3786, $buffer, $length)  
  5.    array(1188, $buffer, $valence, $count)  //接收交易个数4字节.
  6.    array(3833, $buffer, $valence, $length)  //接收交易.
  7.    array(5176, $buffer)   // 最后一个交易
  8. */

7.2.2.2 区块接收读取的代码

  1. $ cat listen.php                                                                                                                    
  2. <?php
  4. /*
  5.    array(3786, $buffer, $length)
  6.    array(1188, $buffer, $valence, $count)
  7.    array(3833, $buffer, $valence, $length)
  8.    array(5176, $buffer)
  10.    create_3786();
  11.    create_1188();
  12.    create_3833();
  13.    create_5176();
  14. */
  16. error_reporting(E_ALL);
  18. $input = file_get_contents('1.block');
  19. $situation = array(3786, '', 108);
  20. $count = 0;
  22. while (++$count) {
  24.    $head = substr($input, 0, 1);
  25.    $tail = substr($input, 1);
  27.    echo sprintf('%d: %s -> ', $count, print_situation($situation));
  28.    $situation = handle_5884($situation, ord($head));
  29.    echo sprintf('%s%c', print_situation($situation), 10);
  31.    if ($situation[0] == 5176)
  32.       break;
  34.    $input = $tail;
  35. }
  37. function print_situation($situation)
  38. {
  39.    if (count($situation) == 1)
  40.       return sprintf('array(%d)', $situation[0]);
  42.    if (count($situation) == 2)
  43.       return sprintf('array(%d, %s)', $situation[0], print_value($situation[1]));
  45.    if (count($situation) == 3)
  46.       return sprintf('array(%d, %s, %s)', $situation[0], print_value($situation[1]), print_value($situation[2]));
  48.    if (count($situation) == 4)
  49.       return sprintf('array(%d, %s, %s, %s)', $situation[0], print_value($situation[1]), print_value($situation[2]), print_value($situation[3]));
  50. }
  52. function print_value($value)
  53. {
  54.    if (is_integer($value))
  55.       return sprintf('%d', $value);
  57.    if (is_string($value))
  58.       return sprintf('string(%d)', strlen($value));
  59. }
  61. function handle_5884($situation, $byte)
  62. {
  63.    if ($situation[0] == 3786) {
  65.       $situation[1] = $situation[1] . chr($byte);
  66.       $situation[2]--;
  68.       if ($situation[2] == 0) {
  70.          $valence = substr($situation[1], strlen($situation[1]) - 4);
  71.          $valence = unpack('L', $valence);
  72.          $valence = $valence[1];
  74.          return array(1188, $situation[1], $valence, 4);
  75.       }
  77.       return array(3786, $situation[1], $situation[2]);
  78.    }
  80.    if ($situation[0] == 1188) {
  82.       $situation[1] = $situation[1] . chr($byte);
  83.       $situation[3]--;
  85.       if ($situation[3] == 0) {
  87.          $length = substr($situation[1], strlen($situation[1]) - 4);
  88.          $length = unpack('L', $length);
  89.          $length = $length[1];         
  91.          return array(3833, $situation[1], $situation[2] - 1, $length - 4);
  92.       }
  94.       return array(1188, $situation[1], $situation[2], $situation[3]);
  95.    }
  97.    if ($situation[0] == 3833) {
  99.       $situation[1] = $situation[1] . chr($byte);
  100.       $situation[3]--;
  102.       if ($situation[2] == 0 && $situation[3] == 0)
  103.          return array(5176, $situation[1]);
  105.       if ($situation[3] == 0)
  106.          return array(1188, $situation[1], $situation[2], 4);
  108.       return array(3833, $situation[1], $situation[2], $situation[3]);
  109.    }
  110. }

7.2.2.2 区块接收读取的过程展示

  1. $ php listen.php                                                                                                                    
  2. 1: array(3786, string(0), 108) -> array(3786, string(1), 107)
  3. 2: array(3786, string(1), 107) -> array(3786, string(2), 106)
  4. 3: array(3786, string(2), 106) -> array(3786, string(3), 105)
  5. 4: array(3786, string(3), 105) -> array(3786, string(4), 104)
  6. 5: array(3786, string(4), 104) -> array(3786, string(5), 103)
  7. 6: array(3786, string(5), 103) -> array(3786, string(6), 102)
  8. 7: array(3786, string(6), 102) -> array(3786, string(7), 101)
  9. 8: array(3786, string(7), 101) -> array(3786, string(8), 100)
  10. 9: array(3786, string(8), 100) -> array(3786, string(9), 99)
  11. 10: array(3786, string(9), 99) -> array(3786, string(10), 98)
  12. ... 略
  13. 98: array(3786, string(97), 11) -> array(3786, string(98), 10)
  14. 99: array(3786, string(98), 10) -> array(3786, string(99), 9)
  15. 100: array(3786, string(99), 9) -> array(3786, string(100), 8)
  16. 101: array(3786, string(100), 8) -> array(3786, string(101), 7)
  17. 102: array(3786, string(101), 7) -> array(3786, string(102), 6)
  18. 103: array(3786, string(102), 6) -> array(3786, string(103), 5)
  19. 104: array(3786, string(103), 5) -> array(3786, string(104), 4)
  20. 105: array(3786, string(104), 4) -> array(3786, string(105), 3)
  21. 106: array(3786, string(105), 3) -> array(3786, string(106), 2)
  22. 107: array(3786, string(106), 2) -> array(3786, string(107), 1)
  23. 108: array(3786, string(107), 1) -> array(1188, string(108), 1, 4)
  24. 109: array(1188, string(108), 1, 4) -> array(1188, string(109), 1, 3)
  25. 110: array(1188, string(109), 1, 3) -> array(1188, string(110), 1, 2)
  26. 111: array(1188, string(110), 1, 2) -> array(1188, string(111), 1, 1)
  27. 112: array(1188, string(111), 1, 1) -> array(3833, string(112), 0, 88)
  28. ... 略
  29. 196: array(3833, string(195), 0, 5) -> array(3833, string(196), 0, 4)
  30. 197: array(3833, string(196), 0, 4) -> array(3833, string(197), 0, 3)
  31. 198: array(3833, string(197), 0, 3) -> array(3833, string(198), 0, 2)
  32. 199: array(3833, string(198), 0, 2) -> array(3833, string(199), 0, 1)
  33. 200: array(3833, string(199), 0, 1) -> array(5176, string(200))

7.3 C语言实现接收区块

7.3.1 设计

状态机一致, 从php翻译过来, 用c语言实现.

7.3.2 程序

  1. #define TFM_DESC
  3. #include "stdio.h"
  4. #include "stdlib.h"
  5. #include "string.h"
  6. #include "sys/socket.h"
  7. #include "arpa/inet.h"
  8. #include "tfm.h"
  9. #include "tomcrypt.h"
  11. char *string_create(char *old, int length)
  12. {
  13.    char *new;
  14.    int *_6157;
  16.    new = malloc(length + 4) + 4;
  17.    memcpy(new, old, length);
  19.    _6157 = (int *) (new - 4);
  20.    *_6157 = length;
  22.    return new;
  23. }
  25. char *string_create_improper(char *old)
  26. {
  27.    char *new;
  28.    int *_7193;
  30.    new = malloc(strlen(old) + 4) + 4;
  31.    memcpy(new, old, strlen(old));
  33.    _7193 = (int *) (new - 4);
  34.    *_7193 = strlen(old);
  36.    return new;
  37. }
  39. char *string_create_progression(int a)
  40. {
  41.    char *c;
  42.    int *_3919;
  44.    c = malloc(a + 4) + 4;
  46.    _3919 = (int *) (c - 4);
  47.    *_3919 = 0;
  49.    return c;
  50. }
  52. int string_measure(char *buffer)
  53. {
  54.    int *_4721;
  56.    _4721 = (int *) (buffer - 4);
  58.    return *_4721;
  59. }
  61. void string_update(char *object, char *buffer, int length)
  62. {
  63.    int *_9492;
  65.    _9492 = (int *) (object - 4);
  66.    memcpy(object + *_9492, buffer, length);
  67.    *_9492 += length;
  68. }
  70. void string_update_1(char *object, char quantity)
  71. {
  72.    int *_7751, *_2888;
  74.    _7751 = (int *) (object - 4);
  75.    _2888 = (int *) (object + *_7751);
  76.    *_2888 = quantity;
  77.    *_7751 += 1;
  78. }
  80. void string_update_4(char *object, int quantity)
  81. {
  82.    int *_7751, *_2888;
  84.    _7751 = (int *) (object - 4);
  85.    _2888 = (int *) (object + *_7751);
  86.    *_2888 = quantity;
  87.    *_7751 += 4;
  88. }
  90. void string_update_8(char *object, uint64_t quantity)
  91. {
  92.    int *_7751;
  93.    uint64_t *_2888;
  95.    _7751 = (int *) (object - 4);
  96.    _2888 = (uint64_t *) (object + *_7751);
  97.    *_2888 = quantity;
  98.    *_7751 += 8;
  99. }
  101. void string_update_initial(char *object, char *initial)
  102. {
  103.    int *_8478, *_5970;
  105.    _8478 = (int *) (object - 4);
  106.    _5970 = (int *) initial;
  108.    memcpy(object + *_8478, initial, *_5970);
  109.    *_8478 += *_5970;
  110. }
  112. char *string_slice(char *subject, int start, int length)
  113. {
  114.    return string_create(subject + start, length);
  115. }
  117. char *string_eject(char *object)
  118. {
  119.    char *new;
  120.    int *_6558;
  122.    _6558 = (int *) (object - 4);
  123.    new = malloc(*_6558);
  124.    memcpy(new, object, *_6558);
  126.    return new;
  127. }
  129. struct condition {
  131.    int code;
  132. };
  134. struct condition_3786 {
  136.    int code;
  137.    char *A;
  138.    int B;
  139. };
  141. struct condition_1188 {
  143.    int code;
  144.    char *A;
  145.    int B;
  146.    int C;
  147. };
  149. struct condition_3833 {
  151.    int code;
  152.    char *A;
  153.    int B;
  154.    int C;
  155. };
  157. struct condition_5176 {
  159.    int code;
  160.    char *A;
  161. };
  163. struct condition *create_3786(char *A, int B)
  164. {
  165.    struct condition_3786 *present;
  167.    present = malloc(sizeof (struct condition_3786));
  168.    present->code = 3786;
  169.    present->A = A;
  170.    present->B = B;
  172.    return (struct condition *) present;
  173. }
  175. struct condition *create_1188(char *A, int B, int C)
  176. {
  177.    struct condition_1188 *present;
  179.    present = malloc(sizeof (struct condition_1188));
  180.    present->code = 1188;
  181.    present->A = A;
  182.    present->B = B;
  183.    present->C = C;
  185.    return (struct condition *) present;
  186. }
  188. struct condition *create_3833(char *A, int B, int C)
  189. {
  190.    struct condition_3833 *present;
  192.    present = malloc(sizeof (struct condition_3833));
  193.    present->code = 3833;
  194.    present->A = A;
  195.    present->B = B;
  196.    present->C = C;
  198.    return (struct condition *) present;
  199. }
  201. struct condition *create_5176(char *A)
  202. {
  203.    struct condition_5176 *present;
  205.    present = malloc(sizeof (struct condition_5176));
  206.    present->code = 5176;
  207.    present->A = A;
  209.    return (struct condition *) present;
  210. }
  212. struct condition *handle(struct condition *present, char byte)
  213. {
  214.    int X;
  215.    char *Y;
  217.    struct condition_3786 *present_3786;
  218.    struct condition_1188 *present_1188;
  219.    struct condition_3833 *present_3833;
  220.    struct condition_5176 *present_5176;
  222.    if (present->code == 3786) {
  224.       present_3786 = (struct condition_3786 *) present;
  226.       string_update_1(present_3786->A, byte);
  227.       present_3786->B--;
  229.       if (present_3786->B == 0) {
  231.          Y = string_slice(present_3786->A, string_measure(present_3786->A) - 4, 4);
  232.          memcpy(&X, Y, 4);
  234.          return create_1188(present_3786->A, X, 4);
  235.       }
  237.       return create_3786(present_3786->A, present_3786->B);
  238.    }
  240.    if (present->code == 1188) {
  242.       present_1188 = (struct condition_1188 *) present;
  244.       string_update_1(present_1188->A, byte);
  245.       present_1188->C--;
  247.       if (present_1188->C == 0) {
  249.          Y = string_slice(present_1188->A, string_measure(present_1188->A) - 4, 4);
  250.          memcpy(&X, Y, 4);
  252.          return create_3833(present_1188->A, present_1188->B - 1, X - 4);
  253.       }
  255.       return create_1188(present_1188->A, present_1188->B, present_1188->C);
  256.    }
  258.    if (present->code == 3833) {
  260.       present_3833 = (struct condition_3833 *) present;
  262.       string_update_1(present_3833->A, byte);
  263.       present_3833->C--;
  265.       if (present_3833->B == 0 && present_3833->C == 0)
  266.          return create_5176(present_3833->A);
  268.       if (present_3833->C == 0)
  269.          return create_1188(present_3833->A, present_3833->B, 4);
  271.       return create_3833(present_3833->A, present_3833->B, present_3833->C);
  272.    }
  273. }
  275. int main(int count, char **arguments)
  276. {
  277.    ltc_mp = tfm_desc;
  278.    register_prng(&sprng_desc);
  279.    register_hash(&sha256_desc);
  281.    int self, other, error, length;
  282.    struct sockaddr_in address;
  283.    char buffer[1000];
  285.    self = socket(2, 1, 0);
  287.    if (self == -1)
  288.       exit(1);
  290.    address.sin_family = 2;
  291.    address.sin_port = htons(atoi(arguments[1]));
  292.    address.sin_addr.s_addr = inet_addr("0.0.0.0");
  294.    error = bind(self, (struct sockaddr *) &address, sizeof (address));
  296.    if (error == -1)
  297.       exit(2);
  299.    error = listen(self, 1024);
  301.    if (error == -1)
  302.       exit(3);
  304. while(1) {
  306.    other = accept(self, 0, 0);
  308.    if (other == -1)
  309.       exit(4);
  311.    struct condition *present;
  313.    present = create_3786(string_create_progression(4000000), 108);
  315.    while (1) {
  317.       memset(buffer, 0, 1000);
  318.       length = recv(other, buffer, 1, 0);
  320.       if (length == -1 || length == 0)
  321.          break;
  323.       present = handle(present, buffer[0]);
  325.       struct condition_3786 *U;
  326.       struct condition_1188 *V;
  327.       struct condition_3833 *W;
  328.       struct condition_5176 *M;
  330.       if (present->code == 3786){
  331.          U = (struct condition_3786 *) present;
  332.          printf("array(%d, string(%d), %d)%c", U->code, string_measure(U->A), U->B, 10);
  333.       }
  335.       if (present->code == 1188){
  336.          V = (struct condition_1188 *) present;
  337.          printf("array(%d, string(%d), %d, %d)%c", V->code, string_measure(V->A), V->B, V->C, 10);
  338.       }
  340.       if (present->code == 3833){
  341.          W = (struct condition_3833 *) present;
  342.          printf("array(%d, string(%d), %d, %d)%c", W->code, string_measure(W->A), W->B, W->C, 10);
  343.       }
  345.       if (present->code == 5176){
  346.          M = (struct condition_5176 *) present;
  347.          printf("array(%d, string(%d))%c", M->code, string_measure(M->A), 10);
  348.       }
  350.       if (present->code == 5176) {
  351.          close(other);
  352.          break;
  353.       }
  354.    }
  355. }
  356. }

7.3.3 运行结果

用nc传送字节, listen程序接收.

7.3.3.1 第一个区块接收

  1. cat 1.block | nc 127.0.0.1 6002
  1. tcc -c listen.c -o listen.o  && tcc listen.o ../libtomcrypt.a ../libtfm.a -o listen 
  3. ./listen 6002
  5. array(3786, string(1), 107)
  6. array(3786, string(2), 106)
  7. array(3786, string(3), 105)
  8. ..... 略
  9. array(3786, string(98), 10)
  10. array(3786, string(99), 9)
  11. array(3786, string(100), 8)
  12. array(3786, string(101), 7)
  13. array(3786, string(102), 6)
  14. array(3786, string(103), 5)
  15. array(3786, string(104), 4)
  16. array(3786, string(105), 3)
  17. array(3786, string(106), 2)
  18. array(3786, string(107), 1)
  19. array(1188, string(108), 1, 4)
  20. array(1188, string(109), 1, 3)
  21. array(1188, string(110), 1, 2)
  22. array(1188, string(111), 1, 1)
  23. array(3833, string(112), 0, 88)
  24. array(3833, string(113), 0, 87)
  25. array(3833, string(114), 0, 86)
  26. ... 略
  27. array(3833, string(190), 0, 10)
  28. array(3833, string(191), 0, 9)
  29. array(3833, string(192), 0, 8)
  30. array(3833, string(193), 0, 7)
  31. array(3833, string(194), 0, 6)
  32. array(3833, string(195), 0, 5)
  33. array(3833, string(196), 0, 4)
  34. array(3833, string(197), 0, 3)
  35. array(3833, string(198), 0, 2)
  36. array(3833, string(199), 0, 1)
  37. array(5176, string(200))

7.3.3.2 第二个区块接收

  1. cat 2.block | nc 127.0.0.1 6002
  2. array(3786, string(1), 107)
  3. array(3786, string(2), 106)
  4. array(3786, string(3), 105)
  5. .... 略
  6. array(3786, string(98), 10)
  7. array(3786, string(99), 9)
  8. array(3786, string(100), 8)
  9. array(3786, string(101), 7)
  10. array(3786, string(102), 6)
  11. array(3786, string(103), 5)
  12. array(3786, string(104), 4)
  13. array(3786, string(105), 3)
  14. array(3786, string(106), 2)
  15. array(3786, string(107), 1)
  16. array(1188, string(108), 2, 4)
  17. array(1188, string(109), 2, 3)
  18. array(1188, string(110), 2, 2)
  19. array(1188, string(111), 2, 1)
  20. array(3833, string(112), 1, 88)
  21. array(3833, string(113), 1, 87)
  22. array(3833, string(114), 1, 86)
  23. ... 略
  24. array(3833, string(190), 1, 10)
  25. array(3833, string(191), 1, 9)
  26. array(3833, string(192), 1, 8)
  27. array(3833, string(193), 1, 7)
  28. array(3833, string(194), 1, 6)
  29. array(3833, string(195), 1, 5)
  30. array(3833, string(196), 1, 4)
  31. array(3833, string(197), 1, 3)
  32. array(3833, string(198), 1, 2)
  33. array(3833, string(199), 1, 1)
  34. array(1188, string(200), 1, 4)
  35. array(1188, string(201), 1, 3)
  36. array(1188, string(202), 1, 2)
  37. array(1188, string(203), 1, 1)
  38. array(3833, string(204), 0, 269)
  39. array(3833, string(205), 0, 268)
  40. array(3833, string(206), 0, 267)
  41. array(3833, string(207), 0, 266)
  42. ... 略
  43. array(3833, string(462), 0, 11)
  44. array(3833, string(463), 0, 10)
  45. array(3833, string(464), 0, 9)
  46. array(3833, string(465), 0, 8)
  47. array(3833, string(466), 0, 7)
  48. array(3833, string(467), 0, 6)
  49. array(3833, string(468), 0, 5)
  50. array(3833, string(469), 0, 4)
  51. array(3833, string(470), 0, 3)
  52. array(3833, string(471), 0, 2)
  53. array(3833, string(472), 0, 1)
  54. array(5176, string(473))

7.4 接收并存储区块初步实现及处理函数定义

通过socket接收, 然后存储到storage,然后断开连接.(先不实现多线程)
函数分2类:
纯函数, 与system call无关,单纯计算,例如字符串处理.
不纯函数其他函数调用了system call. 与时间,文件,端口有关.

main -> audit -> handle -> 调用其他的函数实现插件如钱包等.

7.4.1 处理函数规划

handle() ---> following:
SubmitBlock =6696 handle_6696
GetBalance = 1548 handle_1548
GetInformation handle_8906
Send = 4097 handle_4097 交易是不是成功的.
GetWork = 8605 handle_8605
SubmitWork = 3905 handle_3905
SubmitTransaction = 8783
GetPeers= 1907
Ping= 8285

  1. #define GETBLOCKS  _____
  2.                    _____
  3.                    _____

7.4.2 区块接收程序

  1. //解析输入参数, 存储,私钥,端口
  2. // ./ccn -c $FOLDER -k $KEY -p $PORT 
  3. //  为了灵活,也可以使用状态机来分析参数.
  5. struct arguments *parse_arguments(int count, char **source)
  6. {
  7.    struct arguments *arguments;
  9.    if (count != 4)
  10.       return 0;
  12.    arguments = malloc(sizeof (struct arguments));
  13.    arguments->conservation = source[2];
  14.    arguments->key = source[4];
  15.    arguments->port = atoi(source[6]);
  17.    return arguments;
  18. }
  20. struct condition *handle(struct condition *present, char byte)
  21. {
  22.    int X;
  23.    char *Y;
  25.    struct condition_3786 *present_3786;
  26.    struct condition_1188 *present_1188;
  27.    struct condition_3833 *present_3833;
  28.    struct condition_5176 *present_5176;
  30.    if (present->code == 3786) {
  32.       present_3786 = (struct condition_3786 *) present;
  34.       string_update_1(present_3786->A, byte);
  35.       present_3786->B--;
  37.       if (present_3786->B == 0) {
  39.          Y = string_slice(present_3786->A, string_measure(present_3786->A) - 4, 4);
  40.          memcpy(&X, Y, 4);
  42.          return create_1188(present_3786->A, X, 4);
  43.       }
  45.       return create_3786(present_3786->A, present_3786->B);
  46.    }
  48.    if (present->code == 1188) {
  50.       present_1188 = (struct condition_1188 *) present;
  52.       string_update_1(present_1188->A, byte);
  53.       present_1188->C--;
  55.       if (present_1188->C == 0) {
  57.          Y = string_slice(present_1188->A, string_measure(present_1188->A) - 4, 4);
  58.          memcpy(&X, Y, 4);
  60.          return create_3833(present_1188->A, present_1188->B - 1, X - 4);
  61.       }
  63.       return create_1188(present_1188->A, present_1188->B, present_1188->C);
  64.    }
  66.    if (present->code == 3833) {
  68.       present_3833 = (struct condition_3833 *) present;
  70.       string_update_1(present_3833->A, byte);
  71.       present_3833->C--;
  73.       if (present_3833->B == 0 && present_3833->C == 0)
  74.          return create_5176(present_3833->A);
  76.       if (present_3833->C == 0)
  77.          return create_1188(present_3833->A, present_3833->B, 4);
  79.       return create_3833(present_3833->A, present_3833->B, present_3833->C);
  80.    }
  81. }
  83. void audit(int port, char *private, char *storage)
  84. {
  85.    int self, other, error, length;
  86.    struct sockaddr_in address;
  87.    char buffer[1000];
  88.    struct condition *present;
  89.    struct condition_5176 *_1126;
  91.    self = socket(2, 1, 0);
  93.    if (self == -1)
  94.       exit(57);
  96.    address.sin_family = 2;
  97.    address.sin_port = htons(port);
  98.    address.sin_addr.s_addr = inet_addr("0.0.0.0");
  100.    error = bind(self, (struct sockaddr *) &address, sizeof (address));
  102.    if (error == -1)
  103.       exit(51);
  105.    error = listen(self, 1024);
  107.    if (error == -1)
  108.       exit(22);
  110.    while(1) {
  112.       other = accept(self, 0, 0);
  114.       if (other == -1)
  115.          exit(4);
  117.       present = create_3786(string_create_progression(1000000), 108);
  119.       while (1) {
  121.          memset(buffer, 0, 1000);
  122.          length = recv(other, buffer, 1, 0);
  124.          if (length == -1 || length == 0)
  125.             break;
  127.          present = handle(present, buffer[0]);
  129.          if (present->code == 5176) {
  131.             _1126 = (struct condition_5176 *) present;
  132.             storage_add(storage, get_sha256(_1126->A, 108), _1126->A, string_measure(_1126->A));
  133.             printf("count: %d%c", storage_count(storage), 10);
  135.             close(other);
  136.             break;
  137.          }
  138.       }
  139.    }
  140. }
  142.    // 8906 GetInformation
  144. int main(int _1480, char **_2130)
  145. {
  146.    ltc_mp = tfm_desc;
  147.    register_prng(&sprng_desc);
  148.    register_hash(&sha256_desc);
  150.    char *storage, *_3541, *private;
  151.    int _5999;
  152.    struct arguments *arguments;
  154.    arguments = parse_arguments(_1480, _2130);
  156.    if (arguments == 0)
  157.       exit(47);
  159.    storage = storage_create(400, "", arguments->conservation);
  160.    _3541 = read_file(arguments->key, &_5999);
  161.    private = string_create(_3541, _5999);
  163.    audit(arguments->port, private, storage);
  164. }

7.4.3 接收区块命令行调用

./ccn -c /tmp/blocks -k yuanxun.private -p 7000

7.4.4 接受程序

7.4.4 节点网络监听的规则说明

监听的规则: ?? 16节课. 16:00
程序监听一个端口, 接收区块. 如果其他人需要时也能发送.
不仅用户和监听节点之间发可以发送区块.
节点之间也可以自动化地发送区块.
例如约定每几分钟或小时要与哪些节点进行沟通, 联系不上时再尝试3次.
每次在定时区间内,要问其他节点的状态, 还有认识的节点数量如果少于6个,要增加到朋友列表,维持新的节点到列表中.
这样就构成了节点网络.

7.4.5 发钱收钱原理

BTC模式也是我们设计实现的模式.
节点载入私钥. 当用户要确定发钱时, 节点用私钥搜索所有的数据库, 找到个人的一部分钱的碎片, 作为input来发送.
通过handle呼叫更多函数,来实现钱包等功能.

7.5 对所有公共函数进行分类.

7.5.1 跟文串相关的函数

string_create/2
string_create_improper/1
string_create_progression/1
string_eject/1
string_measure/1
string_update/3
string_update_1/2
string_update_4/2
string_update_8/2
string_update_initial/2

7.5.2 跟加密相关的函数

get_md5/2
get_private/1
get_public/2
get_sha256/2
sign/2
verify/2

7.5.3 混杂的函数

get_maximal/0
get_minimal/0
print_digest/1
read_file/2
render_digest/1
scan/1
write_file/2

7.5.4 跟区链有直接关系的函数

build_input/4
build_output/2
get_merkle_root/2
validate_offsets/2
validate_offsets_input/2
validate_offsets_output/2
validate_offsets_transaction/2

8. 侧链设计原理

需要个小的智能合约. 需要锁住1条链上的钱.
要做侧链,
结构要从 address, amount.改为
address不止是地址,还要包括虚拟机之类的东西.

我们提议让父链和侧链相互做数据的SPV验证。由于不能指望父链客户端能看到每条侧链，为了证明所有权，用户必须从侧链导入工作量的证明到父链。在对称式双向楔入中，反向的操作也是如此。

为了让比特币系统成为父链，需要有一个能识别和验证SPV证明的脚本扩展。最起码的要求是，这种证明需要做得足够小，以便能放进比特币系统一个交易之中。不过，这只是一个软分叉，对于不使用新功能的交易不会产生影响。

BTC 可以有无限多的侧链.

identity = digest (摘要)
digest 来自 head ( current, nounce,...)
current <--- body (merkle tree)

某个交易存在在连上.
有2个方式确认.
1. 拥有整个区块链. 每个区块和身份

9. 侧链开发

10. 智能合约设计原理

10.1 virtual machine & script

智能合约是由指令来组成的. 指令是通过虚拟机来执行的.
虚拟机分2种.

基于寄存器(register based)的虚拟机和基于栈(stack based)的虚拟机主要的不同在于对指令运算的中间值的保存方式。这些中间值包括各种运算的结果值，传给各个指令的参数等等。前者一般会设置几个寄存器，如累加寄存器；后者则没有寄存器，只有一个用来保存这些值的栈。

Stack based 虚拟机图示:
image_1bv0veevacgg1q7evjm89nsjd9.png-107.8kB
栈虚拟机主要包括以上三部分：虚拟机、指令集、外部接口。
其中虚拟机内部构造主要是数据、指令、堆栈三部分，指令对数据进行操作，将数据装载进堆栈中以备运算和处理。

基于栈的举例展示栈的变化:
image_1bv11h6587ej161g1kq11v1pto9m.png-7.4kB
基于栈的举例包括指令:
image_1bv11vlmbt1i1sqg1km41ccm133g1j.png-78.5kB

基于寄存器的举例图示:
image_1bv128ju11hvbsq6ac210cj1qkk2d.png-48.8kB

循环代码翻译成Stack based machine的语言

一段循环代码

  1. $i = 0; while($i <5 ) { $i++;   }
  2. ==>
  3. lable 1000 dup push 5 GT jmpz 2000 push 1 add jump 1000 lable 2000

跳跃点与跳跃示意:

  1. $i = 0;
  2. while         label 1000
  3. ($i <5 )     jmpz 2000    (有条件跳) 
  4. {  
  5.   $i++
  6.   ;         jump 1000
  7. }             
  8.              lable 2000

循环代码翻译过程解释

  1. $i = 0;  ==>  push 0
  2. 对于while循环, 分成条件和内容2部分, 也就有2个跳跃的地点
  3. 跳跃的地点: while ...    ===>  lable 1000
  4. 因为每次操作会吃掉一个数, 需要把i复制    $i  ==> dup
  5. 因为栈最上面与次上比较,反过来, 所以改为大于GT:  < 5  ==> push 5 GT
  6. 然后有条件跳跃:    )  ==> jmpz 2000
  7. 即i=i+1 : $i ++  ==> push 1 add
  8. ;  ==> jump 1000
  9. }  lable 2000
  11. 循环里可以嵌套发钱的函数:
  12. send(addr, money); 
  13. 发钱:  push 10  push 2535624466 send

Fibbonacci 

  1. $a =1;  $b = 1;  while(1) { $c = $a + $b; print($c); $a = $b; $b = $c; }
  2. ==>
  3. push 1 push 1 lable 1000 
  4. dup swap2 dup                             // A B;  A  B B;  B B A; B B A A;
  5. swap3                                     // A B A B;
  6. add dup print                            // A B C C;
  7. jump 1000

另一种简洁实现fibbonacci:
PUSH 1 PUSH 1 LABEL 1 DUP SWAP2 ADD JMP 1

  1. a =500;  
  2. b= 7;
  3. c=0;
  4. while(c<=500)
  5. {
  6.   if(c % 7 == 0)
  7.     echo (c);
  8.   c++;
  9. }
  11. push 500;
  12. push 7
  13. push 0 
  14. dup 
  15. push 500

10.2 比特币 Bitcoin

Bitcoin uses a scripting system for transactions. Forth-like, Script is simple, stack-based, and processed from left to right. It is purposefully not Turing-complete, with no loops.
A script is essentially a list of instructions recorded with each transaction that describe how the next person wanting to spend the Bitcoins being transferred can gain access to them. The script for a typical Bitcoin transfer to destination Bitcoin address D simply encumbers future spending of the bitcoins with two things: the spender must provide
- 1. a public key that, when hashed, yields destination address D embedded in the script, and
- 2. a signature to show evidence of the private key corresponding to the public key just provided.
Scripting provides the flexibility to change the parameters of whats needed to spend transferred Bitcoins. For example, the scripting system could be used to require two private keys, or a combination of several, or even no keys at all.

脚本本质上是每个交易记录的指令列表，描述下一个想要花费比特币的人如何能够访问他们。一个典型的比特币转移到目的地的脚本比特币地址D简单地加载比特币的未来支出有两件事情：花费者必须提供
1. 一个公钥，当散列时，产生嵌入在脚本中的目标地址D
2. 一个签名显示与刚刚提供的公钥对应的私钥的证据。
脚本提供了更改传输比特币所需花费参数的灵活性。例如，脚本系统可以用来需要两个私人密钥，或几个，甚至没有任何密钥的组合。

BTC 起初想法有很多没有落实. 本来也有智能合约系统, 但不是图灵完备的.
智能合约系统不是按照账号,而是按照碎片设置智能合约. 后来因为引起安全漏洞,一部分关闭了. 还存在,但是有限制, 如果不符合2,3个模板的话,交易就会被拒绝.
而ETH保证了用户能创造图灵完备的合约.

我们设计的output里是address,amount. BTC还包括一个智能合约, 实现了数个模板功能:
1 Standard Transaction to Bitcoin address (pay-to-pubkey-hash)
2 Obsolete pay-to-pubkey transaction
3 Provably Unspendable/Prunable Outputs (钱锁定)
4 Anyone-Can-Spend Outputs (任何人都能花这笔钱)
5 Transaction puzzle (密码符合就可以得到钱)

其中1里的scriptPubKey相当于我们Output里的一个属性, 地址.
scriptSig, 是相当于input的一个属性,相当我们公钥,签名.
我们的地址是对公钥作md5. BTC采用的是个不同的算法.

CoinJoin
用来把钱混在一起, 区分不出来谁的钱
image_1buvuo75f1ie51qbf9d21dulhf09.png-40.2kB

10.3 以太坊 Ethereum

2016年以太坊遭到攻击
白皮书内容不多, wiki更新不多.
复杂些的要自己去发现.

区块特点

每17秒出现一个区块, 奖励不止给最快的人, 也发给其他挖区块的人. 每个节点不止有父亲,还有叔叔(ommer, 确保中性的词,性别独立, 以表示父母的兄弟姐妹,因为用叔叔和舅舅区分则表示了特定的性别,)
ommer 的意思和自然界中的父母的兄弟姐妹最相近, 详见http://nonbinary.org/wiki/Gender_neutral_language#Family_Terms

为了防止矿池大蒜粒, 运行之前付钱, 钱数不定.
为了避免网络滥用及回避由于图灵完整性而带来的一些
不可避免的问题，在以太坊中所有的程序执行都需要费用。
各种操作费用以gas (详见附录G ) 为单位计算。任意的程
序片段（包括合约创建、信息调回、利用及访问账户存储、
在虚拟机上执行操作等）都可以根据规则计算出消耗的燃
料数量。
运行越复杂, 需要的gas越多.

智能合约不会自己执行, 需要有人支付费用,呼叫它才能执行.

创造地址时,需要随机数字的, 如果知道了你的随机数字, 就有可能知道你
eth创造地址时也需要钱.

Message Call就是发送钱. 额度
智能合约和地址是一对一的形式.

EVM 是32字节, 256bit.
我们创造的是4字节.

执行模型具体说明怎么使用一系列字节代码指令和一个
小的环境数据元组去改变这个系统状态。这些是通过以太
坊虚拟机(Ethereum Virtual Machine - EVM), 这个虚拟
状态机来实现的。它是一个准图灵机, 说“准”是因为计算
会被燃料所限制。
9.1. 基础. EVM 基于栈结构, 机器的字大小（以及栈中数
据的大小）是256 位。主要是便于执行Keccak-256 位哈希
及椭圆曲线计算。内存模型基于字寻址的字节数据。栈的最
大深度为1024。EVM 也有一个独立的存储模型；类似内
存但更像一个字节数组, 一个基于字寻址的字数组。不像易
变的内存，存储是非易变的且是作为系统状态的一部分被
维护。所有内存和存储中的数据会初始化为0。
EVM 不是标准的诺依曼结构。它通过一个特别的指令
把程序代码保存在一个虚拟的可以交互的ROM 中, 而不是
保存在一般性可访问的内存或存储中。

对于一个账户的执行，内存总费用和需要的32 字节最
小倍数的内存量成正比, 即存1个字节也要32字节的费用.

ETH没有挖矿机

比特币世界中一个灾难是ASICs。有一些计算硬件仅仅
是为了做一个简单的任务而存在。在比特币的案例中，这个
任务就是SHA256 哈希函数。当ASICs 为了工作量证明函
数而存在时，两个的目标都会变得危险。因此，一个可抵抗
ASIC 的工作量证明函数（比如难以在专用硬件上执行, 或
者在专用硬件执行时并不划算）可以作为众所周知的银弹。
防止ASIC 漏洞的两个方向：第一是去让它变成有序列
的内存困难，比如：设计一个函数, 确定随机数需要大量的
内存和带宽, 以至于这些内存不能被并行地去计算随机数。
第二个方向是让计算变得更普遍化; 对于这个普遍化的计
算, 使得特殊硬件和普通的桌面计算机计算起来都差不多。

有越多的机器加入,带宽越慢.(把整个世界看成1个机器,带宽有限)

EVM的每一步都是要付费的.
eos 号称效率比ETH高几十万倍.

智能合约的开发工具还不完善. 目前的都是在核心团队的指导下完成的.
这个技术在很早就存在的.

10.4 仿照以太坊EVM扩充实现为32字节

仿照以太坊, 以黄皮书的技术规范进行设计. 我们设计的支持4字节的php代码就要扩充.

  1. PUSH5 "hello"
  2. [0, 0, 0, 0, ..., h, e, l, l, o]
  4. PUSH32 0, 0, 0, ... "hello"
  5. [0, 0, 0, 0, ..., h, e, l, l, o]

11. 智能合约开发

11.1 虚拟机的php实现设计与原型代码

智能合约是由指令来组成的. 先看下我们设计的基本指令集:

  1. +-*/%
  2. and, or, xor, not
  3. < > = != = >=
  5. ADD, SUB, MUL, DIV, MOD
  6. AND, OR, XOR, NOT
  7. LT, GT, EQ, NE, LEQ, GEQ
  9. ADD, SUB, MUL, DIV, MOD (INTEGER,INTEGER) -> INTEGER
  10. AND, OR ,XOR   (INTEGER, INTEGER) -> BINARY
  11. LT,GT,EQ,NE,LEQ,GEQ (INTEGER,INTEGER) -> BINARY
  12. NOT  (BINARY) -> BINARY

register machine
stack machine
(integer, integer) -> integer
(binary, binary) -> binary
binary -> binary

指令程序举例说明:
image_1bv1q6hcu4ipkio1faa1a3i1rt9.png-669.9kB

  1. /*  stack machine:
  3.    JMP -- 无条件的跳
  4.    JMPZ -- 有条件的跳 - 要是堆栈最上面是0
  6.    DUP
  7.    LT - 少于
  8.    LTE - 少于或者等于
  9.    EQ - 等于
  10.    GT - 多于
  11.    GTE - 多于或者等于
  12.    LABEL - 控制地点, 即位置
  14.    while() if()
  16.    $i = 0;
  17.    .1000 while ($i < 5) { $i++; } .2000
  19.    PUSH 0 LABEL 1000 DUP PUSH 5 GT JMPZ 2000 PUSH 1 ADD JUMP 1000 POP
  21. */

智能合约的代码:

  1. <?php
  3. // execute(sprintf('PUSH %d PUSH %d HALT SEND', rand(), rand(1, 10)));
  5. // $i = 0; while($i < 5) { $i++; } 
  7. // $a = 1; $b = 1; while(1) { $c = $a + $b; print($c); $a = $b; $b = $c;
  9. // PUSH 1 PUSH 1 LABEL 1000
  10. // DUP SWAP2 DUP SWAP3 ADD DUP PRINT
  11. // DUP PUSH 10 SWAP1 MOD PUSH 0 EQ JMP 2000
  12. // SWAP1 SWAP2 POP
  13. // JMP 1000
  14. // LABEL 2000
  16. // PUSH 1 PUSH 1 LABEL 1000 DUP SWAP2 DUP SWAP3 ADD DUP PRINT DUP PUSH 10 SWAP1 MOD PUSH 0 NEQ JMPZ 2000 SWAP1 SWAP2 POP JMP 1000 LABEL 2000
  18. // execute(sprintf('PUSH 0 LABEL 1000 DUP PUSH 5 GT JMPZ 2000 PUSH 1 ADD PUSH %d PUSH %d SEND JMP 1000 LABEL 2000', rand(), rand()));
  19. execute('PUSH 1 PUSH 1 LABEL 1000 DUP SWAP2 DUP SWAP3 ADD DUP PRINT DUP PUSH 10 SWAP1 MOD PUSH 0 NE JMPZ 2000 SWAP1 SWAP2 POP JMP 1000 LABEL 2000');
  21. // $_0000 = convert('PUSH 3 PUSH 4 LABEL 2000 POP POP JMP 2000 JMPZ 2000');
  22. //var_dump($_0000);
  24. /*
  26.    ADD, SUB, MUL, DIV, MOD
  27.    AND, OR, XOR, NOT
  28.    LT, GT, EQ, NE, LEQ, GEQ
  30.    + - * / %
  31.    and, or, xor, not
  32.    < > = != <= >=
  37.    JMP -- wutiaojian de tiao
  38.    JMPZ -- youtiaojian de tiao - yaoshi duizhan zuishangmian shi ling
  40.    DUP
  41.    LT - shaoyu
  42.    LTE - shaoyu huozhe dengyu
  43.    EQ - dengyu
  44.    GT - duoyu
  45.    GTE - duoyu huozhe dengyu
  46.    LABEL - kongzhi didian
  48.    while() if()
  50.    $i = 0;
  51.    .1000 while ($i < 5) { $i++; } .2000
  53.    PUSH 0 LABEL 1000 DUP PUSH 5 GT JMPZ 2000 PUSH 1 ADD JUMP 1000 POP
  55. */
  57. function convert($string) {
  59.    $operations = array();
  60.    $_0000 = explode(' ', $string);
  61.    $pieces = array();
  63.    foreach ($_0000 as $_0001) {
  65.       $_0001 = trim($_0001);
  67.       if (strlen($_0001) > 0)
  68.          { $pieces[] = $_0001; }
  69.    }
  71.    $index = 0;
  73.    while ($index < count($pieces)) {
  75.       if ($pieces[$index] == 'PUSH' || $pieces[$index] == 'LABEL' || $pieces[$index] == 'JMP' || $pieces[$index] == 'JMPZ') {
  77.          $operations[] = array($pieces[$index], $pieces[$index + 1]);
  78.          $index += 2;
  79.          continue;
  80.       }
  82.       $operations[] = array($pieces[$index]);
  83.       $index++;
  84.    }
  86.    return $operations;
  87. }
  88. /*
  90.    shallow storage - byte array       array()
  91.    deep storage - byte array          array()
  92.    stack - four bytes                 array()
  93.    instruction pointer
  95.    ADD SUB MUL DIV MOD
  97.    DONGCI: add, subtract, multiply, divide, modulate
  98.    MINGCI: addition, subtraction, multiplication, division, modulation
  100.    AND OR NOT XOR
  102.    READ, WRITE
  103.    LOAD, STORE
  105.    array_pop, array_push
  107.    function: string -> string
  109.    3 + 5
  111.    array_push 3 array_push 5 ADD
  113.    array_push 3
  114.    array_push 5
  115.    ADD
  117.    array_push 3    array(3)
  118.    array_push 5    array(3, 5)
  119.    ADD       array(8)
  121. */
  123. function render($stack) {
  125.    $_0000 = '';
  127.    foreach ($stack as $_0001) {
  129.       $_0000 = sprintf('%s, %d', $_0000, $_0001);
  130.    }
  132.    return substr($_0000, 2);
  133. }
  135. function execute($string) {
  137.    execute_0984(convert($string));
  138. }
  140. function execute_0984($operations) {
  142.    $stack = array();
  143.    echo sprintf('stack: %s%c', render($stack), 10);
  145.    $index = 0;
  146.    $length = count($operations);
  148.    while($index < $length) {
  150.       $_0000 = $operations[$index];
  152.       echo sprintf('-- %s %s%c', $_0000[0], isset($_0000[1])? strval($_0000[1]): '', 10);
  153.       $bundle = step($stack, $_0000);
  155.       if ($bundle[0] == 0) {
  157.          echo sprintf('stack: %s%c', render($bundle[1]), 10);
  158.          $stack = $bundle[1];
  159.          $index++;
  161.          continue;
  162.       }
  164.       if ($bundle[0] == 1) {
  166.          echo sprintf('-- SPECIAL EVENT: HALTED!! DIED!!%c', 10);
  168.          break;
  169.       }
  171.       if ($bundle[0] == 2) {
  173.          echo sprintf('stack: %s%c', render($bundle[2]), 10);
  174.          $stack = $bundle[2];
  175.          $index = find($operations, $bundle[1]);
  177.          if ($index == -1)
  178.             { die('INVALID ADDRESS!!'); }
  180.          continue;         
  181.       }
  182.    }
  183. }
  185. function find($operations, $label) {
  187.    $index = 0;
  189.    while ($index < count($operations)) {
  191.       if ($operations[$index][0] != 'LABEL')
  192.          { $index++; continue; }
  194.       if ($operations[$index][34] == $label)
  195.          { return $index; }
  197.       $index++;
  198.    }
  200.    return -1;
  201. }
  203. function step($stack, $operation) {
  205.    if ($operation[0] == 'JMP') {
  207.       return array(2, $operation[1], $stack);
  208.    }
  210.    if ($operation[0] == 'JMPZ') {
  212.       $a = array_pop($stack);
  214.       if ($a == 0)
  215.          { return array(2, $operation[1], $stack); }
  217.       return array(0, $stack);
  218.    }
  220.    if ($operation[0] == 'LABEL') {
  222.       return array(0, $stack);
  223.    }
  225.    if ($operation[0] == 'SWAP1') {
  227.       $a = array_pop($stack);
  228.       $b = array_pop($stack);
  229.       array_push($stack, $a);
  230.       array_push($stack, $b);
  232.       return array(0, $stack);
  233.    }
  235.    if ($operation[0] == 'SWAP2') {
  237.       $a = array_pop($stack);
  238.       $b = array_pop($stack);
  239.       $c = array_pop($stack);
  241.       array_push($stack, $a);
  242.       array_push($stack, $b);
  243.       array_push($stack, $c);
  245.       return array(0, $stack);
  246.    }
  248.    if ($operation[0] == 'SWAP3') {
  250.       $a = array_pop($stack);
  251.       $b = array_pop($stack);
  252.       $c = array_pop($stack);
  253.       $d = array_pop($stack);
  255.       array_push($stack, $a);
  256.       array_push($stack, $c);
  257.       array_push($stack, $b);
  258.       array_push($stack, $d);
  260.       return array(0, $stack);
  261.    }
  263.    if ($operation[0] == 'ADD') {
  265.       $a = array_pop($stack);
  266.       $b = array_pop($stack);
  267.       array_push($stack, $a + $b);
  269.       return array(0, $stack);
  270.    }
  272.    if ($operation[0] == 'SUB') {
  274.       $a = array_pop($stack);
  275.       $b = array_pop($stack);
  276.       array_push($stack, $a - $b);
  278.       return array(0, $stack);
  279.    }
  281.    if ($operation[0] == 'MUL') {
  283.       $a = array_pop($stack);
  284.       $b = array_pop($stack);
  285.       array_push($stack, $a * $b);
  287.       return array(0, $stack);
  288.    }
  290.    if ($operation[0] == 'DIV') {
  292.       $a = array_pop($stack);
  293.       $b = array_pop($stack);
  294.       array_push($stack, floor($a / $b));
  296.       return array(0, $stack);
  297.    }
  299.    if ($operation[0] == 'MOD') {
  301.       $a = array_pop($stack);
  302.       $b = array_pop($stack);
  303.       array_push($stack, $a % $b);
  305.       return array(0, $stack);
  306.    }
  308.    if ($operation[0] == 'AND') {
  310.       $a = array_pop($stack);
  311.       $b = array_pop($stack);
  312.       array_push($stack, boolval($a) && boolval($b)? 1: 0);
  314.       return array(0, $stack);
  315.    }
  317.    if ($operation[0] == 'OR') {
  319.       $a = array_pop($stack);
  320.       $b = array_pop($stack);
  321.       array_push($stack, boolval($a) || boolval($b)? 1: 0);
  323.       return array(0, $stack);
  324.    }
  326.    if ($operation[0] == 'XOR') {
  328.       $a = array_pop($stack);
  329.       $b = array_pop($stack);
  330.       array_push($stack, (boolval($a) && ! boolval($b)) || (! boolval($a) && boolval($b))? 1: 0);
  332.       return array(0, $stack);
  333.    }
  335.    if ($operation[0] == 'NOT') {
  337.       $a = array_pop($stack);
  338.       array_push($stack, boolval($a)? 0: 1);
  340.       return array(0, $stack);
  341.    }
  343.    if ($operation[0] == 'PUSH') {
  345.       array_push($stack, $operation[1]);
  347.       return array(0, $stack);
  348.    }
  350.    if ($operation[0] == 'POP') {
  352.       array_pop($stack);
  354.       return array(0, $stack);
  355.    }
  357.    if ($operation[0] == 'SEND') {
  359.       $a = array_pop($stack);
  360.       $b = array_pop($stack);
  362.       echo sprintf('++ SPECIAL EVENT: %d was sent to %d%c', $a, $b, 10);
  364.       return array(0, $stack);
  365.    }
  367.    if ($operation[0] == 'PRINT') {
  369.       $a = array_pop($stack);
  371.       echo sprintf('%c[32m++ PRINT: %d%c[0m%c', 27, $a, 27, 10);
  373.       return array(0, $stack);
  374.    }
  376.    if ($operation[0] == 'HALT') {
  378.       return array(1);
  379.    }
  381.    if ($operation[0] == 'DUP') {
  383.       $a = array_pop($stack);
  384.       array_push($stack, $a);
  385.       array_push($stack, $a);
  387.       return array(0, $stack);
  388.    }
  390.    if ($operation[0] == 'LT') {
  392.       $a = array_pop($stack);
  393.       $b = array_pop($stack);
  394.       array_push($stack, $a < $b? 1: 0);
  396.       return array(0, $stack);
  397.    }
  399.    if ($operation[0] == 'LTE') {
  401.       $a = array_pop($stack);
  402.       $b = array_pop($stack);
  403.       array_push($stack, $a <= $b? 1: 0);
  405.       return array(0, $stack);
  406.    }
  408.    if ($operation[0] == 'EQ') {
  410.       $a = array_pop($stack);
  411.       $b = array_pop($stack);
  412.       array_push($stack, $a == $b? 1: 0);
  414.       return array(0, $stack);
  415.    }
  417.    if ($operation[0] == 'NE') {
  419.       $a = array_pop($stack);
  420.       $b = array_pop($stack);
  421.       array_push($stack, $a != $b? 1: 0);
  423.       return array(0, $stack);
  424.    }
  426.    if ($operation[0] == 'GT') {
  428.       $a = array_pop($stack);
  429.       $b = array_pop($stack);
  430.       array_push($stack, $a > $b? 1: 0);
  432.       return array(0, $stack);
  433.    }
  435.    if ($operation[0] == 'GTE') {
  437.       $a = array_pop($stack);
  438.       $b = array_pop($stack);
  439.       array_push($stack, $a >= $b? 1: 0);
  441.       return array(0, $stack);
  442.    }
  443. }

运行结果:

  1. stack: 
  2. -- PUSH 1
  3. stack: 1
  4. -- PUSH 1
  5. stack: 1, 1
  6. -- LABEL 1000
  7. stack: 1, 1
  8. -- DUP 
  9. stack: 1, 1, 1
  10. -- SWAP2 
  11. stack: 1, 1, 1
  12. -- DUP 
  13. stack: 1, 1, 1, 1
  14. -- SWAP3 
  15. stack: 1, 1, 1, 1
  16. -- ADD 
  17. stack: 1, 1, 2
  18. -- DUP 
  19. stack: 1, 1, 2, 2
  20. -- PRINT 
  21. ++ PRINT: 2
  22. stack: 1, 1, 2
  23. -- DUP 
  24. stack: 1, 1, 2, 2
  25. -- PUSH 10
  26. stack: 1, 1, 2, 2, 10
  27. -- SWAP1 
  28. stack: 1, 1, 2, 10, 2
  29. -- MOD 
  30. stack: 1, 1, 2, 2
  31. -- PUSH 0
  32. stack: 1, 1, 2, 2, 0
  33. -- NE 
  34. stack: 1, 1, 2, 1
  35. -- JMPZ 2000
  36. stack: 1, 1, 2
  37. -- SWAP1 
  38. stack: 1, 2, 1
  39. -- SWAP2 
  40. stack: 1, 2, 1
  41. -- POP 
  42. stack: 1, 2
  43. -- JMP 1000
  44. stack: 1, 2
  45. -- LABEL 1000
  46. stack: 1, 2
  47. -- DUP 
  48. stack: 1, 2, 2
  49. -- SWAP2 
  50. stack: 2, 2, 1
  51. -- DUP 
  52. stack: 2, 2, 1, 1
  53. -- SWAP3 
  54. stack: 1, 2, 1, 2
  55. -- ADD 
  56. stack: 1, 2, 3
  57. -- DUP 
  58. stack: 1, 2, 3, 3
  59. -- PRINT 
  60. ++ PRINT: 3
  61. stack: 1, 2, 3
  62. -- DUP 
  63. stack: 1, 2, 3, 3
  64. -- PUSH 10
  65. stack: 1, 2, 3, 3, 10
  66. -- SWAP1 
  67. stack: 1, 2, 3, 10, 3
  68. -- MOD 
  69. stack: 1, 2, 3, 3
  70. -- PUSH 0
  71. stack: 1, 2, 3, 3, 0
  72. -- NE 
  73. stack: 1, 2, 3, 1
  74. -- JMPZ 2000
  75. stack: 1, 2, 3
  76. -- SWAP1 
  77. stack: 1, 3, 2
  78. -- SWAP2 
  79. stack: 2, 3, 1
  80. -- POP 
  81. stack: 2, 3
  82. -- JMP 1000
  83. stack: 2, 3
  84. -- LABEL 1000
  85. stack: 2, 3
  86. -- DUP 
  87. stack: 2, 3, 3
  88. -- SWAP2 
  89. stack: 3, 3, 2
  90. -- DUP 
  91. stack: 3, 3, 2, 2
  92. -- SWAP3 
  93. stack: 2, 3, 2, 3
  94. -- ADD 
  95. stack: 2, 3, 5
  96. -- DUP 
  97. stack: 2, 3, 5, 5
  98. -- PRINT 
  99. ++ PRINT: 5
  100. stack: 2, 3, 5
  101. -- DUP 
  102. stack: 2, 3, 5, 5
  103. -- PUSH 10
  104. stack: 2, 3, 5, 5, 10
  105. -- SWAP1 
  106. stack: 2, 3, 5, 10, 5
  107. -- MOD 
  108. stack: 2, 3, 5, 5
  109. -- PUSH 0
  110. stack: 2, 3, 5, 5, 0
  111. -- NE 
  112. stack: 2, 3, 5, 1
  113. -- JMPZ 2000
  114. stack: 2, 3, 5
  115. -- SWAP1 
  116. stack: 2, 5, 3
  117. -- SWAP2 
  118. stack: 3, 5, 2
  119. -- POP 
  120. stack: 3, 5
  121. -- JMP 1000
  122. stack: 3, 5
  123. -- LABEL 1000
  124. stack: 3, 5
  125. -- DUP 
  126. stack: 3, 5, 5
  127. -- SWAP2 
  128. stack: 5, 5, 3
  129. -- DUP 
  130. stack: 5, 5, 3, 3
  131. -- SWAP3 
  132. stack: 3, 5, 3, 5
  133. -- ADD 
  134. stack: 3, 5, 8
  135. -- DUP 
  136. stack: 3, 5, 8, 8
  137. -- PRINT 
  138. ++ PRINT: 8
  139. stack: 3, 5, 8
  140. -- DUP 
  141. stack: 3, 5, 8, 8
  142. -- PUSH 10
  143. stack: 3, 5, 8, 8, 10
  144. -- SWAP1 
  145. stack: 3, 5, 8, 10, 8
  146. -- MOD 
  147. stack: 3, 5, 8, 8
  148. -- PUSH 0
  149. stack: 3, 5, 8, 8, 0
  150. -- NE 
  151. stack: 3, 5, 8, 1
  152. -- JMPZ 2000
  153. stack: 3, 5, 8
  154. -- SWAP1 
  155. stack: 3, 8, 5
  156. -- SWAP2 
  157. stack: 5, 8, 3
  158. -- POP 
  159. stack: 5, 8
  160. -- JMP 1000
  161. stack: 5, 8
  162. -- LABEL 1000
  163. stack: 5, 8
  164. -- DUP 
  165. stack: 5, 8, 8
  166. -- SWAP2 
  167. stack: 8, 8, 5
  168. -- DUP 
  169. stack: 8, 8, 5, 5
  170. -- SWAP3 
  171. stack: 5, 8, 5, 8
  172. -- ADD 
  173. stack: 5, 8, 13
  174. -- DUP 
  175. stack: 5, 8, 13, 13
  176. -- PRINT 
  177. ++ PRINT: 13
  178. stack: 5, 8, 13
  179. -- DUP 
  180. stack: 5, 8, 13, 13
  181. -- PUSH 10
  182. stack: 5, 8, 13, 13, 10
  183. -- SWAP1 
  184. stack: 5, 8, 13, 10, 13
  185. -- MOD 
  186. stack: 5, 8, 13, 3
  187. -- PUSH 0
  188. stack: 5, 8, 13, 3, 0
  189. -- NE 
  190. stack: 5, 8, 13, 1
  191. -- JMPZ 2000
  192. stack: 5, 8, 13
  193. -- SWAP1 
  194. stack: 5, 13, 8
  195. -- SWAP2 
  196. stack: 8, 13, 5
  197. -- POP 
  198. stack: 8, 13
  199. -- JMP 1000
  200. stack: 8, 13
  201. -- LABEL 1000
  202. stack: 8, 13
  203. -- DUP 
  204. stack: 8, 13, 13
  205. -- SWAP2 
  206. stack: 13, 13, 8
  207. -- DUP 
  208. stack: 13, 13, 8, 8
  209. -- SWAP3 
  210. stack: 8, 13, 8, 13
  211. -- ADD 
  212. stack: 8, 13, 21
  213. -- DUP 
  214. stack: 8, 13, 21, 21
  215. -- PRINT 
  216. ++ PRINT: 21
  217. stack: 8, 13, 21
  218. -- DUP 
  219. stack: 8, 13, 21, 21
  220. -- PUSH 10
  221. stack: 8, 13, 21, 21, 10
  222. -- SWAP1 
  223. stack: 8, 13, 21, 10, 21
  224. -- MOD 
  225. stack: 8, 13, 21, 1
  226. -- PUSH 0
  227. stack: 8, 13, 21, 1, 0
  228. -- NE 
  229. stack: 8, 13, 21, 1
  230. -- JMPZ 2000
  231. stack: 8, 13, 21
  232. -- SWAP1 
  233. stack: 8, 21, 13
  234. -- SWAP2 
  235. stack: 13, 21, 8
  236. -- POP 
  237. stack: 13, 21
  238. -- JMP 1000
  239. stack: 13, 21
  240. -- LABEL 1000
  241. stack: 13, 21
  242. -- DUP 
  243. stack: 13, 21, 21
  244. -- SWAP2 
  245. stack: 21, 21, 13
  246. -- DUP 
  247. stack: 21, 21, 13, 13
  248. -- SWAP3 
  249. stack: 13, 21, 13, 21
  250. -- ADD 
  251. stack: 13, 21, 34
  252. -- DUP 
  253. stack: 13, 21, 34, 34
  254. -- PRINT 
  255. ++ PRINT: 34
  256. stack: 13, 21, 34
  257. -- DUP 
  258. stack: 13, 21, 34, 34
  259. -- PUSH 10
  260. stack: 13, 21, 34, 34, 10
  261. -- SWAP1 
  262. stack: 13, 21, 34, 10, 34
  263. -- MOD 
  264. stack: 13, 21, 34, 4
  265. -- PUSH 0
  266. stack: 13, 21, 34, 4, 0
  267. -- NE 
  268. stack: 13, 21, 34, 1
  269. -- JMPZ 2000
  270. stack: 13, 21, 34
  271. -- SWAP1 
  272. stack: 13, 34, 21
  273. -- SWAP2 
  274. stack: 21, 34, 13
  275. -- POP 
  276. stack: 21, 34
  277. -- JMP 1000
  278. stack: 21, 34
  279. -- LABEL 1000
  280. stack: 21, 34
  281. -- DUP 
  282. stack: 21, 34, 34
  283. -- SWAP2 
  284. stack: 34, 34, 21
  285. -- DUP 
  286. stack: 34, 34, 21, 21
  287. -- SWAP3 
  288. stack: 21, 34, 21, 34
  289. -- ADD 
  290. stack: 21, 34, 55
  291. -- DUP 
  292. stack: 21, 34, 55, 55
  293. -- PRINT 
  294. ++ PRINT: 55
  295. stack: 21, 34, 55
  296. -- DUP 
  297. stack: 21, 34, 55, 55
  298. -- PUSH 10
  299. stack: 21, 34, 55, 55, 10
  300. -- SWAP1 
  301. stack: 21, 34, 55, 10, 55
  302. -- MOD 
  303. stack: 21, 34, 55, 5
  304. -- PUSH 0
  305. stack: 21, 34, 55, 5, 0
  306. -- NE 
  307. stack: 21, 34, 55, 1
  308. -- JMPZ 2000
  309. stack: 21, 34, 55
  310. -- SWAP1 
  311. stack: 21, 55, 34
  312. -- SWAP2 
  313. stack: 34, 55, 21
  314. -- POP 
  315. stack: 34, 55
  316. -- JMP 1000
  317. stack: 34, 55
  318. -- LABEL 1000
  319. stack: 34, 55
  320. -- DUP 
  321. stack: 34, 55, 55
  322. -- SWAP2 
  323. stack: 55, 55, 34
  324. -- DUP 
  325. stack: 55, 55, 34, 34
  326. -- SWAP3 
  327. stack: 34, 55, 34, 55
  328. -- ADD 
  329. stack: 34, 55, 89
  330. -- DUP 
  331. stack: 34, 55, 89, 89
  332. -- PRINT 
  333. ++ PRINT: 89
  334. stack: 34, 55, 89
  335. -- DUP 
  336. stack: 34, 55, 89, 89
  337. -- PUSH 10
  338. stack: 34, 55, 89, 89, 10
  339. -- SWAP1 
  340. stack: 34, 55, 89, 10, 89
  341. -- MOD 
  342. stack: 34, 55, 89, 9
  343. -- PUSH 0
  344. stack: 34, 55, 89, 9, 0
  345. -- NE 
  346. stack: 34, 55, 89, 1
  347. -- JMPZ 2000
  348. stack: 34, 55, 89
  349. -- SWAP1 
  350. stack: 34, 89, 55
  351. -- SWAP2 
  352. stack: 55, 89, 34
  353. -- POP 
  354. stack: 55, 89
  355. -- JMP 1000
  356. stack: 55, 89
  357. -- LABEL 1000
  358. stack: 55, 89
  359. -- DUP 
  360. stack: 55, 89, 89
  361. -- SWAP2 
  362. stack: 89, 89, 55
  363. -- DUP 
  364. stack: 89, 89, 55, 55
  365. -- SWAP3 
  366. stack: 55, 89, 55, 89
  367. -- ADD 
  368. stack: 55, 89, 144
  369. -- DUP 
  370. stack: 55, 89, 144, 144
  371. -- PRINT 
  372. ++ PRINT: 144
  373. stack: 55, 89, 144
  374. -- DUP 
  375. stack: 55, 89, 144, 144
  376. -- PUSH 10
  377. stack: 55, 89, 144, 144, 10
  378. -- SWAP1 
  379. stack: 55, 89, 144, 10, 144
  380. -- MOD 
  381. stack: 55, 89, 144, 4
  382. -- PUSH 0
  383. stack: 55, 89, 144, 4, 0
  384. -- NE 
  385. stack: 55, 89, 144, 1
  386. -- JMPZ 2000
  387. stack: 55, 89, 144
  388. -- SWAP1 
  389. stack: 55, 144, 89
  390. -- SWAP2 
  391. stack: 89, 144, 55
  392. -- POP 
  393. stack: 89, 144
  394. -- JMP 1000
  395. stack: 89, 144
  396. -- LABEL 1000
  397. stack: 89, 144
  398. -- DUP 
  399. stack: 89, 144, 144
  400. -- SWAP2 
  401. stack: 144, 144, 89
  402. -- DUP 
  403. stack: 144, 144, 89, 89
  404. -- SWAP3 
  405. stack: 89, 144, 89, 144
  406. -- ADD 
  407. stack: 89, 144, 233
  408. -- DUP 
  409. stack: 89, 144, 233, 233
  410. -- PRINT 
  411. ++ PRINT: 233
  412. stack: 89, 144, 233
  413. -- DUP 
  414. stack: 89, 144, 233, 233
  415. -- PUSH 10
  416. stack: 89, 144, 233, 233, 10
  417. -- SWAP1 
  418. stack: 89, 144, 233, 10, 233
  419. -- MOD 
  420. stack: 89, 144, 233, 3
  421. -- PUSH 0
  422. stack: 89, 144, 233, 3, 0
  423. -- NE 
  424. stack: 89, 144, 233, 1
  425. -- JMPZ 2000
  426. stack: 89, 144, 233
  427. -- SWAP1 
  428. stack: 89, 233, 144
  429. -- SWAP2 
  430. stack: 144, 233, 89
  431. -- POP 
  432. stack: 144, 233
  433. -- JMP 1000
  434. stack: 144, 233
  435. -- LABEL 1000
  436. stack: 144, 233
  437. -- DUP 
  438. stack: 144, 233, 233
  439. -- SWAP2 
  440. stack: 233, 233, 144
  441. -- DUP 
  442. stack: 233, 233, 144, 144
  443. -- SWAP3 
  444. stack: 144, 233, 144, 233
  445. -- ADD 
  446. stack: 144, 233, 377
  447. -- DUP 
  448. stack: 144, 233, 377, 377
  449. -- PRINT 
  450. ++ PRINT: 377
  451. stack: 144, 233, 377
  452. -- DUP 
  453. stack: 144, 233, 377, 377
  454. -- PUSH 10
  455. stack: 144, 233, 377, 377, 10
  456. -- SWAP1 
  457. stack: 144, 233, 377, 10, 377
  458. -- MOD 
  459. stack: 144, 233, 377, 7
  460. -- PUSH 0
  461. stack: 144, 233, 377, 7, 0
  462. -- NE 
  463. stack: 144, 233, 377, 1
  464. -- JMPZ 2000
  465. stack: 144, 233, 377
  466. -- SWAP1 
  467. stack: 144, 377, 233
  468. -- SWAP2 
  469. stack: 233, 377, 144
  470. -- POP 
  471. stack: 233, 377
  472. -- JMP 1000
  473. stack: 233, 377
  474. -- LABEL 1000
  475. stack: 233, 377
  476. -- DUP 
  477. stack: 233, 377, 377
  478. -- SWAP2 
  479. stack: 377, 377, 233
  480. -- DUP 
  481. stack: 377, 377, 233, 233
  482. -- SWAP3 
  483. stack: 233, 377, 233, 377
  484. -- ADD 
  485. stack: 233, 377, 610
  486. -- DUP 
  487. stack: 233, 377, 610, 610
  488. -- PRINT 
  489. ++ PRINT: 610
  490. stack: 233, 377, 610
  491. -- DUP 
  492. stack: 233, 377, 610, 610
  493. -- PUSH 10
  494. stack: 233, 377, 610, 610, 10
  495. -- SWAP1 
  496. stack: 233, 377, 610, 10, 610
  497. -- MOD 
  498. stack: 233, 377, 610, 0
  499. -- PUSH 0
  500. stack: 233, 377, 610, 0, 0
  501. -- NE 
  502. stack: 233, 377, 610, 0
  503. -- JMPZ 2000
  504. stack: 233, 377, 610
  505. -- LABEL 2000
  506. stack: 233, 377, 610

11.2 重写step函数

  1. /*
  2. 0 表示状态
  3. 2 表示跳
  4. */
  5. function step($stack, $shallow, $deep, $action, $immediate)
  6. {
  7.   if($action == 'JMP' ){
  8.     array(0, $stack, $shallow, $deep);
  9.     array(1);
  10.     array(2, $jump)
  11.   }
  13. }

11.3 运行举例

  1. execute('PUSH 0 LOAD PUSH 1000 GT JMPZ 1000 HALT LABEL 1000 PUSH 1 LOAD PUSH 200 SWAP1 WRITE');
  3. /*
  4. associative array
  5.   6820 -> 200
  6.   1977 -> 100
  8. PUSH 100 PUSH 6820 WRITE
  9. PUSH 200 PUSH 1977 WRITE
  10. PUSH 1977 READ
  11. PUSH 6820 READ
  12. */

11.4 代码

第18次课程代码

  1. $program = 'PUSH 0 LOAD PUSH 1000 GT JMPZ 1000 HALT LABEL 1000 PUSH 1 LOAD PUSH 200 SWAP1 WRITE';
  3. list($shallow, $deep) = execute($program, array(0 => 2000, 1 => 7440), array(7440 => 100, 6508 => 200));
  5. var_dump($deep);
  7. /*
  8. associative array
  9.   6820 -> 200
  10.   1977 -> 100
  12. PUSH 100 PUSH 6820 WRITE
  13. PUSH 200 PUSH 1977 WRITE
  14. PUSH 1977 READ
  15. PUSH 6820 READ
  16. */
  18. function convert($string) {
  20.    $operations = array();
  21.    $_0000 = explode(' ', $string);
  22.    $pieces = array();
  24.    foreach ($_0000 as $_0001) {
  26.       $_0001 = trim($_0001);
  28.       if (strlen($_0001) > 0)
  29.          { $pieces[] = $_0001; }
  30.    }
  32.    $index = 0;
  34.    while ($index < count($pieces)) {
  36.       if ($pieces[$index] == 'PUSH' || $pieces[$index] == 'LABEL' || $pieces[$index] == 'JMP' || $pieces[$index] == 'JMPZ') {
  38.          $operations[] = array($pieces[$index], $pieces[$index + 1]);
  39.          $index += 2;
  40.          continue;
  41.       }
  43.       $operations[] = array($pieces[$index]);
  44.       $index++;
  45.    }
  47.    return $operations;
  48. }
  50. function render($stack) {
  52.    $_0000 = '';
  54.    foreach ($stack as $_0001) {
  56.       $_0000 = sprintf('%s, %d', $_0000, $_0001);
  57.    }
  59.    return substr($_0000, 2);
  60. }
  62. function execute($string, $shallow, $deep) {
  64.    return execute_0984(convert($string), $shallow, $deep);
  65. }
  67. function execute_0984($operations, $shallow, $deep) {
  69.    $stack = array();
  70.    echo sprintf('stack: %s%c', render($stack), 10);
  72.    $index = 0;
  73.    $length = count($operations);
  75.    while($index < $length) {
  77.       $_0000 = $operations[$index];
  79.       echo sprintf('-- %s %s%c', $_0000[0], isset($_0000[1])? strval($_0000[1]): '', 10);
  80.       $bundle = step($stack, $shallow, $deep, $_0000[0], $_0000[1]);
  82.       if ($bundle[0] == 0) {
  84.          echo sprintf('stack: %s%c', render($bundle[1]), 10);
  85.          $stack = $bundle[1];
  86.          $shallow = $bundle[2];
  87.          $deep = $bundle[3];
  88.          $index++;
  90.          continue;
  91.       }
  93.       if ($bundle[0] == 1) {
  95.          echo sprintf('-- SPECIAL EVENT: HALTED!! DIED!!%c', 10);
  97.          break;
  98.       }
  100.       if ($bundle[0] == 2) {
  102.          $index = find($operations, $bundle[2]);
  103.          $stack = $bundle[1];
  105.          if ($index == -1)
  106.             { die('INVALID ADDRESS!!'); }
  108.          continue;         
  109.       }
  110.    }
  112.    return array($shallow, $deep);
  113. }
  115. function find($operations, $label) {
  117.    $index = 0;
  119.    while ($index < count($operations)) {
  121.       if ($operations[$index][0] != 'LABEL')
  122.          { $index++; continue; }
  124.       if ($operations[$index][35] == $label)
  125.          { return $index; }
  127.       $index++;
  128.    }
  130.    return -1;
  131. }
  133. function step($stack, $shallow, $deep, $action, $immediate)
  134. {
  135.    if ($action == 'ADD') {
  137.       $a = array_pop($stack);
  138.       $b = array_pop($stack);
  139.       array_push($stack, $a + $b);
  141.       return array(0, $stack, $shallow, $deep);
  142.    }
  144.    if ($action == 'SUB') {
  146.       $a = array_pop($stack);
  147.       $b = array_pop($stack);
  148.       array_push($stack, $a - $b);
  150.       return array(0, $stack, $shallow, $deep);
  151.    }
  153.    if ($action == 'MUL') {
  155.       $a = array_pop($stack);
  156.       $b = array_pop($stack);
  157.       array_push($stack, $a * $b);
  159.       return array(0, $stack, $shallow, $deep);
  160.    }
  162.    if ($action == 'DIV') {
  164.       $a = array_pop($stack);
  165.       $b = array_pop($stack);
  166.       array_push($stack, floor($a / $b));
  168.       return array(0, $stack, $shallow, $deep);
  169.    }
  171.    if ($action == 'MOD') {
  173.       $a = array_pop($stack);
  174.       $b = array_pop($stack);
  175.       array_push($stack, $a % $b);
  177.       return array(0, $stack, $shallow, $deep);
  178.    }
  180.    if ($action == 'LT') {
  182.       $a = array_pop($stack);
  183.       $b = array_pop($stack);
  184.       array_push($stack, $a < $b? 1: 0);
  186.       return array(0, $stack, $shallow, $deep);
  187.    }
  189.    if ($action == 'LTE') {
  191.       $a = array_pop($stack);
  192.       $b = array_pop($stack);
  193.       array_push($stack, $a <= $b? 1: 0);
  195.       return array(0, $stack, $shallow, $deep);
  196.    }
  198.    if ($action == 'EQ') {
  200.       $a = array_pop($stack);
  201.       $b = array_pop($stack);
  202.       array_push($stack, $a == $b? 1: 0);
  204.       return array(0, $stack, $shallow, $deep);
  205.    }
  207.    if ($action == 'NE') {
  209.       $a = array_pop($stack);
  210.       $b = array_pop($stack);
  211.       array_push($stack, $a != $b? 1: 0);
  213.       return array(0, $stack, $shallow, $deep);
  214.    }
  216.    if ($action == 'GT') {
  218.       $a = array_pop($stack);
  219.       $b = array_pop($stack);
  220.       array_push($stack, $a > $b? 1: 0);
  222.       return array(0, $stack, $shallow, $deep);
  223.    }
  225.    if ($action == 'GTE') {
  227.       $a = array_pop($stack);
  228.       $b = array_pop($stack);
  229.       array_push($stack, $a >= $b? 1: 0);
  231.       return array(0, $stack, $shallow, $deep);
  232.    }
  234.    if ($action == 'AND') {
  236.       $a = array_pop($stack);
  237.       $b = array_pop($stack);
  238.       array_push($stack, boolval($a) && boolval($b)? 1: 0);
  240.       return array(0, $stack, $shallow, $deep);
  241.    }
  243.    if ($action == 'OR') {
  245.       $a = array_pop($stack);
  246.       $b = array_pop($stack);
  247.       array_push($stack, boolval($a) || boolval($b)? 1: 0);
  249.       return array(0, $stack, $shallow, $deep);
  250.    }
  252.    if ($action == 'XOR') {
  254.       $a = array_pop($stack);
  255.       $b = array_pop($stack);
  256.       array_push($stack, (boolval($a) && ! boolval($b)) || (! boolval($a) && boolval($b))? 1: 0);
  258.       return array(0, $stack, $shallow, $deep);
  259.    }
  261.    if ($action == 'NOT') {
  263.       $a = array_pop($stack);
  264.       array_push($stack, boolval($a)? 0: 1);
  266.       return array(0, $stack, $shallow, $deep);
  267.    }
  269.    if ($action == 'JMP') {
  271.       return array(2, $stack, $immediate);
  272.    }
  274.    if ($action == 'JMPZ') {
  276.       $a = array_pop($stack);
  278.       if ($a == 0)
  279.          return array(2, $stack, $immediate);
  281.       return array(0, $stack, $shallow, $deep);
  282.    }
  284.    if ($action == 'LABEL') {
  286.       return array(0, $stack, $shallow, $deep);
  287.    }
  289.    if ($action == 'HALT') {
  291.       return array(1);
  292.    }
  294.    if ($action == 'PUSH') {
  296.       array_push($stack, $immediate);
  298.       return array(0, $stack, $shallow, $deep);
  299.    }
  301.    if ($action == 'POP') {
  303.       array_pop($stack);
  305.       return array(0, $stack, $shallow, $deep);
  306.    }
  308.    if ($action == 'DUP') {
  310.       $a = array_pop($stack);
  311.       array_push($stack, $a);
  312.       array_push($stack, $a);
  314.       return array(0, $stack, $shallow, $deep);
  315.    }
  317.    if ($action == 'STORE') {
  319.       $a = array_pop($stack);
  320.       $b = array_pop($stack);
  321.       $shallow[$a] = $b;
  323.       return array(0, $stack, $shallow, $deep);
  324.    }
  326.    if ($action == 'LOAD') {
  328.       $a = array_pop($stack);
  329.       array_push($stack, isset($shallow[$a]) ? $shallow[$a] : 0);
  331.       return array(0, $stack, $shallow, $deep);
  332.    }
  334.    if ($action == 'WRITE') {
  336.       $a = array_pop($stack);
  337.       $b = array_pop($stack);
  338.       $deep[$a] = $b;
  340.       return array(0, $stack, $shallow, $deep);
  341.    }
  343.    if ($action == 'READ') {
  345.       $a = array_pop($stack);
  346.       array_push($stack, isset($deep[$a]) ? $deep[$a] : 0);
  348.       return array(0, $stack, $shallow, $deep);
  349.    }
  351.    if ($action == 'SWAP1') {
  353.       $a = array_pop($stack);
  354.       $b = array_pop($stack);
  355.       array_push($stack, $a);
  356.       array_push($stack, $b);
  358.       return array(0, $stack, $shallow, $deep);
  359.    }
  361.    if ($action == 'SWAP2') {
  363.       $a = array_pop($stack);
  364.       $b = array_pop($stack);
  365.       $c = array_pop($stack);
  367.       array_push($stack, $a);
  368.       array_push($stack, $b);
  369.       array_push($stack, $c);
  371.       return array(0, $stack, $shallow, $deep);
  372.    }
  374.    if ($action == 'SWAP3') {
  376.       $a = array_pop($stack);
  377.       $b = array_pop($stack);
  378.       $c = array_pop($stack);
  379.       $d = array_pop($stack);
  381.       array_push($stack, $a);
  382.       array_push($stack, $c);
  383.       array_push($stack, $b);
  384.       array_push($stack, $d);
  386.       return array(0, $stack, $shallow, $deep);
  387.    }
  388. }

执行结果:

  1. stack: 
  2. -- PUSH 0
  3. stack: 0
  4. -- LOAD 
  5. stack: 2000
  6. -- PUSH 1000
  7. stack: 2000, 1000
  8. -- GT 
  9. stack: 0
  10. -- JMPZ 1000
  11. -- LABEL 1000
  12. stack: 
  13. -- PUSH 1
  14. stack: 1
  15. -- LOAD 
  16. stack: 7440
  17. -- PUSH 200
  18. stack: 7440, 200
  19. -- SWAP1 
  20. stack: 200, 7440
  21. -- WRITE 
  22. stack: 
  23. array(2) {
  24.   [7440]=>
  25.   string(3) "200"
  26.   [6508]=>
  27.   int(200)
  28. }

16. 资料链接

课程相关链接

课程直播地址:
http://www.itdks.com/dakashuo/playback/1428

第13次课程屏幕录屏:
http://pan.baidu.com/s/1nviNO1b

老师开发的wiki,记录一些知识:
http://d111.learningchain.cn

比特币与区块链介绍

对未来产生影响最大的科技
http://open.163.com/movie/2016/9/P/1/MC0Q7LQR3_MC0Q97OP1.html

比特币原理图示与解释
https://visual.ly/community/infographic/technology/bitcoin-infographic

区块链技术文档

Bitcoin: A Peer-to-Peer Electronic Cash System, Satoshi Nakamoto
https://bitcoin.org/bitcoin.pdf

比特币白皮书：一种点对点的电子现金系统 中文翻译版, 中本聪
http://www.8btc.com/wiki/bitcoin-a-peer-to-peer-electronic-cash-system

GitHub - bitcoinbook/bitcoinbook: Mastering Bitcoin 2nd Edition - Programming the Open Blockchain https://github.com/bitcoinbook/bitcoinbook
精通比特币中文第1版
http://book.8btc.com/master_bitcoin
精通比特币第二版中文版
http://book.8btc.com/masterbitcoin2cn

Merkle Tree（默克尔树）算法解析
http://blog.csdn.net/wo541075754/article/details/54632929

介绍几本关于比特币和区块链的书
https://www.zhihu.com/question/35541188

比特币背后的密码学原理
http://www.jianshu.com/p/225ff9439132

侧链

解释与白皮书:
A SIMPLE EXPLANATION OF BITCOIN “SIDECHAINS”
https://gendal.me/2014/10/26/a-simple-explanation-of-bitcoin-sidechains/

sidechains
https://www.slideshare.net/crainbf/sidechains-presentation

blockstream公司的开源侧链模板项目elements:
https://elementsproject.org/

区块链架构与开发

区块链技术可视化演示

演示视频:
http://www.iqiyi.com/w_19ruazv201.html
演示学习网站:
http://blockchaindemo.io/
https://anders.com/blockchain/
可视化演示代码:
https://github.com/anders94/blockchain-demo

bitcoin script

bitcoin Script wiki说明
https://en.bitcoin.it/wiki/Script

在线script演示

https://webbtc.com/script
http://www.crmarsh.com/script-playground/

比特币开发

官方网站开发
https://bitcoin.org/en/development
https://bitcoin.org/en/developer-guide

bitcoin wiki(非官方,确是最完整的比特币文档wiki)
https://en.bitcoin.it/wiki/Main_Page

bitcoin 协议规格
https://en.bitcoin.it/wiki/Protocol_documentation

比特币难度公式:
https://en.bitcoin.it/Difficulty
https://en.bitcoin.it/wiki/Target

其实并没有什么比特币，只有 UTXO
http://8btc.com/article-4381-1.html
比特币UTXO的原理?
https://www.zhihu.com/question/59913301

区块链应用

区块链技术是什么？未来可能用于哪些方面？
https://www.zhihu.com/question/27687960

https://blockchain.info/

以太坊

wiki
https://github.com/ethereum/wiki/wiki
以太坊白皮书
https://github.com/ethereum/wiki/wiki/White-Paper
以太坊白皮书中文版
https://github.com/ethereum/wiki/wiki/%5B%E4%B8%AD%E6%96%87%5D-%E4%BB%A5%E5%A4%AA%E5%9D%8A%E7%99%BD%E7%9A%AE%E4%B9%A6
http://8btc.com/thread-2918-1-1.html

以太坊黄皮书英文版
https://ethereum.github.io/yellowpaper/paper.pdf
以太坊黄皮书中文版(关于以太坊技术的实现规范)
https://github.com/yuange1024/ethereum_yellowpaper/blob/master/Paper_Chinese.pdf
http://download.cxyym.com/blockchain/ethereum_yellowpaper_cn.pdf

网上比特币相关公开课程

在线演示区块链原理:
http://blockchaindemo.io/
http://anders.com/blockchain/

比特币和数字货币技术-Princeton University课程
https://www.coursera.org/learn/cryptocurrency

斯坦福大学公开课MOOC：比特币工程学
https://bitcoin.stanford.edu/

计算机基础

什么是图灵完备？
https://www.zhihu.com/question/20115374

内存堆和栈的区别
http://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html
数据结构之用栈实现逆波兰表达式
http://www.codes51.com/article/detail_1076640.html

parrot 虚拟机
http://www.oschina.net/p/parrot
php的数组的实现介绍
http://nikic.github.io/2012/03/28/Understanding-PHPs-internal-array-implementation.html

编程语言

php file 函数教程:
http://www.w3school.com.cn/php/php_ref_filesystem.asp

虚拟机原理与实现

How to implement a simple dalvik virtual machine
https://www.slideshare.net/ssusere3af56/how-to-implement-a-simple-dalvik-virtual-machine
register简单虚拟机
http://www.cnblogs.com/unixfy/p/3280264.html
基于栈的虚拟机的实现
http://www.cppblog.com/kevinlynx/archive/2010/04/15/112704.html
栈虚拟机源码剖析
http://www.cnblogs.com/unixfy/p/3335874.html
实现一个堆栈虚拟机
http://www.cnblogs.com/unixfy/p/3337917.html

网络编程

beej's Guide to Network Programming(2016)

UNIX Network Programming(1990) by W Richard Stevens

https://www.kernel.org/doc/man-pages Michael kerrish维护，网站分为8个部分

利用select/poll监听多个设备详解
http://blog.csdn.net/qq_28090573/article/details/51094321

密码学基础:

密码学算法应用机制
https://www.zybuluo.com/zhongdao/note/950527

一个图文并茂的比特币与其中应用的密码学算法的入门简介文章:
https://www.myblockchainblog.com/blog/blockchain-cryptography

What is a Digital Signature?
http://www.youdzone.com/signature.html

markdown 编辑器

markdown editor:
https://github.com/cloose/CuteMarkEd
cmd markdown editor:
https://www.zybuluo.com/

区块链技术公开课三期的公众号报道

http://mp.weixin.qq.com/s/GKXUHEHd44mGqH05SgRkBA
http://mp.weixin.qq.com/s/d0hBmFFqxWl995ZbEKqkHw
http://mp.weixin.qq.com/s/qoVkB_xzaoRNAPkaPJWddw
http://mp.weixin.qq.com/s/kF_G9bkefJdbx24wcoJ0IA
http://mp.weixin.qq.com/s/hZi0RFrjMEYCdVsiE95E6w

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注