关于holiman/uint256的代码辅助阅读
本文首先介绍了Big Endian 和 Little Endian的定义和区别，接着介绍uint256的数据结构，以及使用的字节序，然后介绍了如何使用uint256，最后做一下总结。
关于字节序：Big Endian 和 Little Endian
字节序，也就是字节的顺序，指的是多字节的数据在内存中的存放顺序。
Big Endian 和 Little Endian
Big Endian 是指低地址端 存放 高位字节。
Little Endian 是指低地址端 存放 低位字节。
各自的优势
Big Endian： 符号位的判定固定为第一个字节，容易判断正负。
Little Endian： 长度为1，2，4字节的数，排列方式都是一样的，数据类型转换非常方便。
数据结构
uint256的组成由4个uint64组成的数组，并且是用的little-endian序列，也就是说Int[3]是最高有效，Int[0]是最低有效，type Int [4]uint64
序列化
在Int中定了4中方法用于Int和byte数组之间的转换，函数如下
func (z *Int) SetBytes(buf []byte) *Int
func (z *Int) Bytes32() [32]byte
func (z *Int) Bytes20() [20]byte
func (z *Int) Bytes() []byte其中转换成bytes的方法有三种，两种是固定长度，一种是不定长。根据代码我们可以看到，不定长的函数Bytes是定长函数Bytes32返回值切片；
// Bytes32 returns the value of z as a 32-byte big-endian array.
func (z *Int) Bytes32() [32]byte {
// The PutUint64()s are inlined and we get 4x (load, bswap, store) instructions.
var b [32]byte
binary.BigEndian.PutUint64(b[0:8], z[3])
binary.BigEndian.PutUint64(b[8:16], z[2])
binary.BigEndian.PutUint64(b[16:24], z[1])
binary.BigEndian.PutUint64(b[24:32], z[0])
return b
}
// Bytes returns the value of z as a big-endian byte slice.
func (z *Int) Bytes() []byte {
b := z.Bytes32()
return b[32-z.ByteLen():]
}初始化的几种方法
Int的初始化有三种方法，NewInt返回值为0的Int，FromBig是将*big.Int转换成Int，FromHex将16进制的字符串转换成Int。
// NewInt returns a new zero-initialized Int.
func NewInt() *Int {
return &Int{}
}
func FromBig(b *big.Int) (*Int, bool)
func FromHex(hex string) (*Int, error)正负的表示，最大值和最小值
因为Int的String方法返回的是Hex字符串，所以不是很直观的判断到底是正数还是负数，下面的函数可以用来判定，这个Int是正数还是负数；
func (z *Int) Sign() int {
if z.IsZero() {
return 0
}
if z[3] < 0x8000000000000000 {
return 1
}
return -1
}上面的函数可以看出只要 z[3] < 0x8000000000000000，即是负数，所以正数最大是：0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff，-1表示为
0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff,最大的负数就是0x8000000000000000000000000000000000000000000000000000000000000000
常用的加减乘除
代码太多，我们简单分析下加减运算，加法运算是针对[4]uint64数组中的数据进行运算，因为最低有效位在[0]uint64中，所以是从下表0开始进行计算的；
Add和AddOverflow的区别是如果最高有效位有进位运算，那么就是Overflow；
同理我们可以自行分析减乘除运算；
// Add sets z to the sum x+y
func (z *Int) Add(x, y *Int) *Int {
var carry uint64
z[0], carry = bits.Add64(x[0], y[0], 0)
z[1], carry = bits.Add64(x[1], y[1], carry)
z[2], carry = bits.Add64(x[2], y[2], carry)
z[3], _ = bits.Add64(x[3], y[3], carry)
return z
}
// Add64 returns the sum with carry of x, y and carry: sum = x + y + carry.
// The carry input must be 0 or 1; otherwise the behavior is undefined.
// The carryOut output is guaranteed to be 0 or 1.
//
// This function's execution time does not depend on the inputs.
func Add64(x, y, carry uint64) (sum, carryOut uint64) {
sum = x + y + carry
// The sum will overflow if both top bits are set (x & y) or if one of them
// is (x | y), and a carry from the lower place happened. If such a carry
// happens, the top bit will be 1 + 0 + 1 = 0 (&^ sum).
carryOut = ((x & y) | ((x | y) &^ sum)) >> 63
return
}
// AddOverflow sets z to the sum x+y, and returns whether overflow occurred
func (z *Int) AddOverflow(x, y *Int) bool {
var carry uint64
z[0], carry = bits.Add64(x[0], y[0], 0)
z[1], carry = bits.Add64(x[1], y[1], carry)
z[2], carry = bits.Add64(x[2], y[2], carry)
z[3], carry = bits.Add64(x[3], y[3], carry)
return carry != 0
}
// Sub sets z to the difference x-y
func (z *Int) Sub(x, y *Int) *Int {
var carry uint64
z[0], carry = bits.Sub64(x[0], y[0], 0)
z[1], carry = bits.Sub64(x[1], y[1], carry)
z[2], carry = bits.Sub64(x[2], y[2], carry)
z[3], _ = bits.Sub64(x[3], y[3], carry)
return z
}
// Sub32 returns the difference of x, y and borrow, diff = x - y - borrow.
// The borrow input must be 0 or 1; otherwise the behavior is undefined.
// The borrowOut output is guaranteed to be 0 or 1.
//
// This function's execution time does not depend on the inputs.
func Sub32(x, y, borrow uint32) (diff, borrowOut uint32) {
diff = x - y - borrow
// The difference will underflow if the top bit of x is not set and the top
// bit of y is set (^x & y) or if they are the same (^(x ^ y)) and a borrow
// from the lower place happens. If that borrow happens, the result will be
// 1 - 1 - 1 = 0 - 0 - 1 = 1 (& diff).
borrowOut = ((^x & y) | (^(x ^ y) & diff)) >> 31
return
}逻辑运算或与非
逻辑运算就的原理很简单，就是按位进行逻辑运算，具体的代码如下
// Not sets z = ^x and returns z.
func (z *Int) Not(x *Int) *Int {
z[3], z[2], z[1], z[0] = ^x[3], ^x[2], ^x[1], ^x[0]
return z
}
// Or sets z = x | y and returns z.
func (z *Int) Or(x, y *Int) *Int {
z[0] = x[0] | y[0]
z[1] = x[1] | y[1]
z[2] = x[2] | y[2]
z[3] = x[3] | y[3]
return z
}
// And sets z = x & y and returns z.
func (z *Int) And(x, y *Int) *Int {
z[0] = x[0] & y[0]
z[1] = x[1] & y[1]
z[2] = x[2] & y[2]
z[3] = x[3] & y[3]
return z
}
// Xor sets z = x ^ y and returns z.
func (z *Int) Xor(x, y *Int) *Int {
z[0] = x[0] ^ y[0]
z[1] = x[1] ^ y[1]
z[2] = x[2] ^ y[2]
z[3] = x[3] ^ y[3]
return z
}
总结
本文带领大家简单的了解uin256库的实现，目前最新版代码的以太坊虚拟机使用的就是这个库。还有很多的函数以及用法需要大家去慢慢探索。
未来可期，一路前行！