有过区块链开发相关工作经验的同学知道，要开发智能合约的应用，你首先需要通过geth同步以太坊主网，这意味着你需要从其他节点下载很多数据。另外在使用区块链技术时，例如支付，接收数字货币时，“钱包”应用需要发送一系列数据给对方，当我们需要通过网络收发数据时就需要对数据进行序列化。

前面我们了解了很多数据结构，例如有限群，椭圆曲线，公钥，私钥等，相关数据在应用时都需要通过网络进行数据传输，因此相关的数据结构需要进行序列化。对于椭圆曲线上一个点，在序列化时通常采用一种叫做非压缩SEC(standard for efficient cryptography)的数据格式，其步骤为：
1，在开头添加0x04作为标志
2，放置点的x坐标数值，它有32字节
3，放置点的y坐标数值，他有32字节。

相应的序列化代码如下：

    def sec(self):
        '''
        sec压缩在开头写入04,然后跟着32字节的x坐标值,最后跟着32字节的y坐标值
        '''
        return b'\x04' + self.x.num.to_bytes(32, 'big') + self.y.num.to_bytes(32, 'big')

既然有非压缩那就有对应的压缩形态SEC，由于椭圆曲线关于x轴对称，因此给定一个x坐标，它最多对应两个y坐标，这两个y互为相反数。但由于我们作用在椭圆曲线上的点都是有限群里面的元素，对于含有p个元素的群而言(注意到p是素数)，如果y是群里面的元素，那么"-y"就是p-y，如果y是偶数，那么p-y就是奇数，反之如果y是奇数，那么p-y就是偶数。利用这个特点我们可以压缩y坐标对应的内容。

于是给定椭圆曲线上一点(x,y),压缩形态SEC生成的步骤为：
1，如果y是奇数，那么以0x03开头，如果是偶数则以0x02开头
2，添加32字节的x坐标值
于是相应实现代码就是：

 def sec(self, compressed = True):
        if compressed:
            if self.y.num % 2 == 0:
                return b'\x02' + self.x.num.to_bytes(32, 'big')
            else:
                return b'\x03' + self.x.num.to_bytes(32, 'big')
        '''
        sec压缩在开头写入04,然后跟着32字节的x坐标值,最后跟着32字节的y坐标值
        '''
        return b'\x04' + self.x.num.to_bytes(32, 'big') + self.y.num.to_bytes(32, 'big')

相对于非压缩形态，压缩形态的序列化就节省了32字节。既然节省掉y，那么接收方收到数据后就需要还原它，还记得椭圆曲线的格式为 y ^ 2 = x^3 + a * x + b，我们知道了x的值，那意味着知道了y平方的值，现在我们需要计算y的值。

假设w, v为有限群的元素，并且有w^2 = v，其中群元素总共有p个。现在我们知道v，我们需要计算w。如果p % 4 = 3，那么我们有好的算法能快速计算w。由于p % 4 = 3, 于是有(p+1) % 4 = 0。也就是(p+1) 能整除4，也就是(p+1) / 4 是一个整数。根据费马小定理 w ^ (p-1) % p = 1, 于是有w ^ 2 = w ^ 2 * 1 = w ^ 2 * (W ^ (p-1) ) = w ^ (p + 1)，由于p是奇数，因此(p+1)就能整除2，也就是(p+1)/2 是一个整数，于是就有 w = w ^ ((p+1)/2)。

上面我们提到(p+1)/4是一个整数，于是就有 w = w ^ ((p+1)/2) = w ^ (2 * (p+1)/2) = (w ^ 2) ^ ((p+1)/4) = v ^ ((p+1)/4)，于是如果 w ^ 2 = v, 并且有 p % 4 = 3, 那么 w = v ^ ((p+1)/4)。对于比特币使用的椭圆曲线，p值恰好能满足p % 4 = 3。这样一来，我们就将开方运算转为求指数运算，由此有限群元素开方运算的实现代码为：

P = 2 ** 256 - 2 ** 32 - 977
class BitcoinFieldElement(FieldElemet):  #S256Field
    def __init__(self, num, prime = None):
        super().__init__(num, P)
    def __repr__(self):
        return "{:x}".format(self.num).zfill(64)  # 填满64个数字

    def sqrt(self):
        return self ** ((P+1) // 4)

我们看看如何解析压缩形态的SEC格式数据，其实现方法为：

    def parse(self, sec_bin): #解析sec压缩数据
        if sec_bin[0] == 4: #非压缩sec格式
            x = int.from_bytes(sec_bin[1:33], 'big')
            y = int.from_bytes(sec_bin[33:65], 'big')
            return BitcoinEllipticPoint(x = x, y = y)

        #在压缩sec的格式下，先获取x，然后计算y的平方，最后使用开方算法获得y的值
        is_even = sec_bin[0] == 2
        x = BitcoinEllipticPoint(int.from_bytes(sec_bin[1:], 'big'))
        #y ^ 2 = x ^3 + 7
        alpha = x ** 3 + BitcoinEllipticPoint(B)
        beta = alpha.sqrt()
        '''
        在实数域中,y会对应一正一负两个值，在有限域中同理，如果y和(p-y)互为正和负.
        也就是在有限群中，如果y满足椭圆方程，那么p-y同样满足椭圆方程。由于比特币对应有限群中元素个数P为素数，
        因此如果y 是偶数，那么p-y就是奇数，如果y是奇数，那么p-y是偶数。于是在压缩SEC格式中，如果开头标志位为0x02，
        那么如果计算出来的y是奇数，那么就要采用P-y
        '''
        if beta.num % 2 == 0: #y是偶数，P-y是奇数
            even_beta = beta
            odd_beta = BitcoinFieldElement(P - beta.num)
        else: #y是奇数，P-y是偶数
            even_beta = BitcoinFieldElement(P - beta.num)
            odd_beta = beta

        if is_even:
            return BitcoinEllipticPoint(x, even_beta)
        else:
            return BitcoinEllipticPoint(x, odd_beta)

接下来，我们给几个私钥e，通过e * G 获得对应公钥，然后看看公钥对应的SEC压缩格式数据，代码如下：

'''
给定如下私钥，求它公钥的压缩sec个数：
5001， 2019 ^ 5, 0xdeadbeef54321
'''
priv = PrivateKey(5001)
print(priv.point.sec(True))

priv = PrivateKey(2019 ** 5)
print(priv.point.sec(True))

priv = PrivateKey(0xdeadbeef54321)
print(priv.point.sec(True))

上面代码运行后结果如下：

0357a4f368868a8a6d572991e484e664810ff14c05c0fa023275251151fe0e53d1
02933ec2d2b111b92737ec12f1c5d20f3233a0ad21cd8b36d0bca7a0cfa5cb8701
0296be5b1292f6c856b3c5654e886fc13511462059089cdf9c479623bfcbe77690

另外还需要序列化的结构就是签名。他有两个数值需要处理，分别是s和r，这两个值没有逻辑上的关联，因此不能像上面那样压缩。在区块链中用于序列化签名的格式叫DER(Distinguished Encoding sinatures)。DER格式如下：
1，以0x30字节开头
2，添加s和r的长度之和，通常情况下是(0x44和0x45)。
3，添加0x02作为分隔符
4，添加r的长度（一字节）将r转换为大端字节形式，如果它开头的字节>=0x80，那么先添加一个0x00然后添加r的内容，
5，添加s的长度（1字节），将s转为大端格式，如果它首字节>=0x80那么先添加一个0x00,后面才跟着s的内容。
由于r是256位数值，因此它最多32字节，如果它首字节>=0x80，那么我们需要在其前面添加0x00，因此r最多有33字节。s同理可以推断。我们看看代码实现：

class Signature:
    def __init__(self, r, s):
        self.r = r
        self.s = s

    def __repr__(self):
        return f"Signature({hex(self.r)}, {hex(self.s)})"

    def der(self):
        #现将r转换为大端格式
        rbin = self.r.to_bytes(32, byteorder='big')
        #去掉开始的0x00内容
        rbin = rbin.lstrip(b'\0x00')
        if rbin[0] & 0x80: # 如果头字节>=0x80，在前头添加0x00
            rbin = '\0x00' + rbin
        #以0x2开头，接着是r的长度，最后是r的内容
        result = bytes([2, len(rbin)]) + rbin

        sbin = self.s.to_bytes(32, byteorder='big')
        sbin.lstrip(b'\0x00')
        if sbin[0] & 0x80:
            sbin = b'0x00' + sbin
        result += bytes([2, len(sbin)]) + sbin
        '''
        以0x30开头，跟着是r和s的总长度，然后是r和s的编码
        '''
        print(f"der total bytes:{len(result)}")
        return bytes([0x30, len(result)]) + result

我们运行上面编码试试：

sig = Signature(0x37206a0610995c58074999cb9767b87af4c4978db68c06e8e6e81d282047a7c6,
                0x8ca63759c1157ebeaec0d03cecca119fc9a75bf8e6d0fa65c841c8e2738cdaec)
print(f"signature der format:{sig.der().hex()}")

代码运行后结果如下：

signature der format:3048022037206a0610995c58074999cb9767b87af4c4978db68c06e8e6e81d282047a7c60224307830308ca63759c1157ebeaec0d03cecca119fc9a75bf8e6d0fa65c841c8e2738cdaec

由于目前所有编码都是二进制格式，这种格式有个问题就是不利于人的阅读理解。因此比特币后来采用base58来将二进制数据再次进行编码，之所以不用base64是因为后者有限字符容易令人混淆，例如数字0和字母O,小写的l和大写的I，于是使用base58能避免这些问题，我们看看base58编码实现：

'''
base58 的编码字符没有小写的l和大写的I,以及大写的字母O
'''
BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
def encode_base58(s):
    '''
    先统计要编码的数据以多少个0开头
    '''
    count = 0
    for c in s:
        if c == 0:
            count += 1
        else:
            break

    num = int.from_bytes(s, 'big')
    prefix = '1' * count
    result = ''
    while num > 0:
        num, mod = divmod(num, 58)
        result = BASE58_ALPHABET[mod] + result

    return prefix + result

我们试试上面代码：

'''
测试base58编码
'''
encode = encode_base58(bytes.fromhex('7c076ff316692a3d7eb3c3bb0f8b1488cf72e1afcd929e29307032997a838a3d'))
print(f"base58 encode:{encode}")

上面代码运行后得到的编码内容为：

9MA8fRQrT4u8Zj8ZRd6MAiiyaxb2Y1CMpvVkHQu5hVM6

base58编码本身有很多毛病，在市场上已经很少用，只是它某些特定特点正好能在区块链或比特币上用到。在以太坊或比特币应用上，数字货币在转账时需要有对应的接收地址，而这个地址的编码就使用到了base58，我们看看具体流程：
1，如果地址来自主网，那么以0x00开头，如果来自测试网络则以0x6f开头。
2，拿到SEC编码（可以是压缩也可以非压缩）,对其进行sha256哈希，然后把结果再次进行ripemd160哈希，这个过程叫hash160操作。
3，把第一和第二步所得结果前后连接起来
4，将第3步结果进行sha256哈希，取开头4个字节
5，将第3和第4步所得结果结合起来，进行base58编码
第5步所得结果也叫校验和，假设我们已经有了第3步的结果，然后看看如何实现第4，5两步，代码如下：

'''
实现地址编码的第4，5两步
'''
def encode_base58_checksum(b):
    return encode_base58(b + hashlib.sha256(b).digest()[:4])

上面提到的hash160操作其实可以直接调用hashlib接口来实现：

def hash160(s):
    return hashlib.new('ripemd160', hashlib.sha256(s).digest()).digest()
'''
在比特币应用中,哈希256都会连续执行两次以增强安全性
'''
def hash256(s):
    return hashlib.sha256(hashlib.sha256(s).digest()).digest()

我们把这些步骤正好到椭圆曲线的点中：

class BitcoinEllipticPoint(EllipticPoint):
    ....
    def hash160(self, compressed=True):
        return hash160(self.sec(compressed))

    def address(self, compressed=True, testnet=False):
        h160 = self.hash160(compressed)
        if testnet:
            prefix = b'\x6f'
        else:
            prefix = b'\x00'
        return encode_base58_checksum(prefix + h160)

我们运行上面实现的逻辑看看：

'''
测试椭圆曲线点的地址编码
'''
priv = PrivateKey(5002)
print(f"address for uncompressed SEC on testnet:{priv.point.address(compressed = False, testnet = True)}")

代码运行后结果如下：

address for uncompressed SEC on testnet:mmTPbXQFxboEtNRkwfh6K51jvdtHLxGeMA

还有一个数据结构需要序列化，那就是私钥。这个东西由于非常敏感，一旦你的私钥丢失，你所有的货币资产就会被别人窃取，因此我们通常不会在网络上传输私钥，但极个别时刻需要这么做，因此我们也需要对私钥进行序列化，它对应的格式叫WIF(Wallet Import Format),它的序列化步骤如下：
1，如果是主网私钥，以0x80开头，如果是测试网以0xef开头
2，将私钥转换为大端字节数组进行编码
3，如果公钥使用压缩SEC格式，那么在末尾添加0x01
4，将1，2，3三个步骤所得结果结合起来
5，将第四步进行sha256（也就是连续两轮256哈希）运算，取结果的前4个字节
6，将步骤4和5结合，使用base58进行编码
我们看看相应的代码实现：

class PrivateKey:
    ....
        def wif(self, compressed = True, testnet = False):
        #先将秘钥转换为大端字节序
        secret_bytes = self.secret.to_bytes(32, 'big')
        if testnet: #根据主网还是测试网添加前缀
            prefix = b'\xef'
        else:
            prefix = b'\x80'

        if compressed: # 根据压缩形态添加后缀
            suffix = b'\x01'
        else:
            suffix = b'\01'

        return encode_base58_checksum(prefix + secret_bytes + suffix)

我们实验一下秘钥的序列化功能：

''
检验秘钥的序列化功能
'''
priv = PrivateKey(5003)
print(f"secret key wif:{priv.wif(True, True)}")

上面代码运行后结果为：

secret key wif:cMahea7zqjxrtgAbB7LSGbcQUr1uX1ojuat9jZodMN8rFTv2sfUK

比特币应用的代码很混乱，中本聪混淆着使用大端字节序和小端字节序，这是创始人的特权，就像鲁迅写错别字就成为了“通假字”，因此我们还需要了解小端编码的实现：

'''
我们使用一段文字进行256哈希形成秘钥，然后设置秘钥的地址格式
'''
secret_text = "this is my secret key"
secret = little_endian_to_int(hash256(secret_text.encode('utf-8')))
priv = PrivateKey(secret)
print(f"secret key address:{priv.point.address(testnet=True)}")

上面代码运行后所得结果为：

secret key address:mtg8uRgVQHjPiX15mmt7FVZeqSUbkUn3h3

我们这节内容很多，好在逻辑并不复杂，主要就是比较繁琐。代码下载路径：https://github.com/wycl16514/blockchain-serialization.git