NIST Warning:阅读本文,需要至少幼儿园中班数学水平,要能数到10!对那些只会1以内加法的码农,请在有经验的码农陪同下观看本文。
背景知识
本节主要介绍cadence随机数在盲盒中的应用。
盲盒玩法是很多NFT的首选,从NBA Top Shot 到冰墩墩,都是如此。区块链盲盒最大的魅力就在于其“公平、公正、公开”的随机性。而如何保证这个“随机性”,则是盲盒合约编写的关键。
这里就先介绍一点点数学背景知识:
首先,计算机基本是无法产生真正“随机数”的,主要是计算机的精度总是有限的。当然,计算机可以产生在大家有生之年,无法破解其规律的随机数,也就是“伪随机数”,目前大部分编程语言生成的都是这类随机数。
再者,去中心化的区块链上产生“随机数”,比一般的web2.0服务器上更加困难。主要是因为区块链是分布式的,所有节点需要对链上状态改变达成共识,也就是说,交易在所有节点上的计算结果都是一样的。如果存在随机的操作码,则不同节点将获得不同的结果,网络就没法达成共识。
基于上述原因,以太坊Solidity本身是不内置随机数函数的,这就需要自己设计随机数。目前最常见的思路,就是基于时间等不断变化、不可预测的要素,使用哈希等运算,生成一个非常大的整数,作为随机数。
Solidity一个基本的的生成随机数的方法如下所述:
uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty)))
其中:block.timestamp 为区块的时间
block.difficulty 为区块的难度
链上生成随机数的核心是在交易被打包到区块之前,尽可能的选取不可预测的种子(数)来生成随机数。
上面这两个要素对普通用户而言是无法预测的,也就是说在一笔交易中,这笔交易什么时候发生,被谁打包到区块中,对用户来说是不可知的,但是一旦被打包到区块中,这些值就是确定的了。因此,上面这种随机数产生方式是基本可行的。
当然,如果有足够的利益驱动,节点是可以持续对区块进行打包,直到计算出对自己有利的随机数,才打包区块,也是可以的,但这样一般是得不偿失的,除非奖池有一个小目标。
Cadence中也有类似的函数:
fun getCurrentBlock(): Block
pub struct Block {
// hash of the block.
pub let id: [UInt8; 32]
//The height of the block.
pub let height: UInt64
// The timestamp of the block.
pub let timestamp: UFix64
}
可以按照类似的方法,使用flow区块的height、id、timestamp构造Cadence的随机数函数, 一个简单的实现如下所示:
let my_block = getCurrentBlock()
let cur_time = my_block.timestamp
let cur_time_data: [UInt8] = cur_time.toBigEndianBytes() // `[73, 150, 2, 210]`
let data_rand = HashAlgorithm.KECCAK_256.hash(cur_time_data) //[UInt8]
data_rand就是生成的256位随机数,因为cadence函数生成的是32个UInt8的数组,自己根据位数转换成Uint256即可。
上述的方法相对比较简单,但有个明显的不足之处,就是一个区块中产生的“随机数”都是一样的,如果区块时间比较长,一段时间内大家可能都抽到了1等奖@#¥#@!@。Solidity中的也有一些改进方法,主要是加入更多业务相关的随机要素,好比用户的钱包地址等,然后再进行多次哈希运行等。
由于众多web3.0应用都依赖于随机数,因此,就有一些专门做区块链随机数的团队,典型的如Chainlink开发的可验证随机函数(VRF),其利用去中心化的预言机来生成链上随机数,其API也是提供一个256位的随机整数。
当然,Flow的Cadence中就有自带的随机函数:
fun unsafeRandom(): UInt64
太赞了!笔者大致看了Flow Go的源代码,产生随机数方式和solidity产生随机数的基本思路应该是一致的(不完全确定)。由于flow的区块时间比较短(秒级),因此,大部分场景下,直接使用这个函数就行了,下面就大致讲一些不同的NFT场景,怎么应用这个函数。
因为unsafeRandom()生成的是64位的随机无符号整数,一般就是一个非常大的数(例如2039449844162889432)。而NFT应用中,一般是需要一个例如0-9这样比较小的随机数,具体怎么使用这个大的随机数呢?
按照码农的一般经验,用一个非常大的随机数,生成一个小范围的随机数,用取模运算就行,如N是我们得到的一个大随机数,要获得一个0-9之间的随机数,就用10当做模。N mod 10 就能获得一个0到9的随机数。当然,在随机数足够大,而模非常小的情况下,这个方法是没有问题的。
盲盒应用
下面就基于取模方法,具体到NFT几个常见的盲盒的场景,讲一下Cadence随机函数的使用。
1 按照相同的概率抽取。这个是最常见的,就是预先铸造好全部的NFT,然后用户从中随机抽取一个。类似于转盘抽奖或者年会活动的抽奖箱。
图 1 cadence如何实现这个幸运大转盘?
具体而言,好比预先铸造了10个NFT,存放在数组nftList里面,下标 index就是从0到9。第一个用户抽取时,就需要产生一个0-9的随机数,按照前面讲的。
let n1 = unsafeRandom() // 产生一个大的随机整数
然后模10,n1 mode 10, 也就是 :
Index1 = n1%10 // 产生了一个0-9的随机数。
nftList[index1] 就是第一个用户抽取的NFT了。
第二个用户来抽取的时候,就剩下9个nft了,就需要从数组中删除掉第一个用户抽取的NFT。当前数据下标就是0-8了,这时就需要产生一个0-8的随机数:
let n2 = unsafeRandom() // 产生一个大的随机整数
index2 = n2%9 //产生一个0到8的随机数
nftList[index2] 就是第一个用户抽取到的NFT了 。
后续的用户就依次类推即可。
我们来看一段具体的线上合约代码:
let indexPackAvailable = unsafeRandom() % UInt64(packTemplate.packsAvailable.length)
let templateIDs = packTemplate.packsAvailable[indexPackAvailable]!
packTemplate.packsAvailable.remove(at: indexPackAvailable)
第1行代码,就是用大的随机数按照数组长度取模,随机获得一个数组的下标index。这里需要注意,取模%运算符两边的类型要一致。
第2行代码,就是根据上一步取得的随机数组下标,获得对应的数组元素。
第3行代码,就是删除已经抽取的数组元素。
合约地址:
类似的使用形式还有很多。像图1中的大转盘,大家可以想想怎么用Cadence实现?
2 按照不同的概率抽取。比如抽取每个物品或者属性获得概率是不一样的。具体好比还是大转盘,转到每个奖品的概率是不一样的。或者是NFT游戏中,随机生成不同稀有度的装备或者属性,典型的如魔兽世界,装备有白色(普通),绿色(优秀),蓝色(精良),紫色(史诗)和橙色(传说)几个级别,越好的,获得的概率就越低。
图 2 概率不一样的随机应用该如何设计
我们就以魔兽世界装备为例,抽取一次装备,获得各个颜色的装备概率如下:
表1:不同颜色装备的获得概率
装备颜色/稀有度 |
获得概率 |
白色(普通) |
50% |
绿色(优秀) |
30% |
蓝色(精良) |
14% |
紫色(史诗) |
5% |
橙色(传说) |
1% |
这个需求,用幼儿园数学水准解决,貌似还是有点难度的。
不过不要怕,我们还是从一个简单的例子看起:就只有2个颜色的装备,白色获取概率为60%,绿色获取概率为40%。
根据场景1,我们是可以获得一个0-9的随机数的,那么,我们还是用大小为10的数组存放数据,前6个位置index=[0,5]存放白色装备,后4个位置index=[6,9]存放绿色装备。那么每次随机抽取一次,“显然”,抽到白色装备的概率就是6/10=60%, 抽到绿色装备的概率就是4/10=40%。看到了吧,只要思想不滑坡,能数到9就能解决这个“复杂”的问题。
图3 按照不同概率进行抽取
当然,如果是类似61%,39%这样的比例分布,那就用[0,99]的数组就行。稀有度不止2类?那就把[0,99]分成更多段就行。啊?还有小数,类似14.1%,39.5%这样的小数?那就用[0,999]这样的数组就行了,也就是根据小数位不同,进行比例扩充即可。
当然,在具体代码实现的时候,可以简单一些,只需要预定义每类随机稀有度对应区间即可,也就是记录首尾两个位置,然后看随机数掉到哪个区间即可,具体代码如下所示:
//功能:给定物品的概率分布,随机获得一个物品
//输入:属性和对应的概率值,例如 {"White":0.5, "Green":0.3, "Blue":0.14,"Purple":0.05,"Orange":0.01},概率之和需要=1
//返回:按照不同属性给定概率,返回一个属性,上面输入例子返回就是 颜色,如 "Blue"
pub fun get_rand_nft(item_prob:{String:UFix64}): String {
let prob_list = item_prob.values
let nft_list = item_prob.keys
//step 1, build area
let ratio:UFix64 = 1000.0
var nft_area_list:[UFix64] = [0.0]
var prob_sum:UFix64 = 0.0
for item in prob_list {
prob_sum = prob_sum + item*ratio
nft_area_list.append(prob_sum)
}
//step 2, get index
let big_int = unsafeRandom() //UInt64,can't run in playground, need testnet or emu
//let big_int:UInt64 = 999923
let base_mod = UInt64(ratio) //same to ratio
let rand_index = UInt32(big_int % base_mod)
var item_index = 0
for item in nft_area_list {
if 0.0 == item { // 第一个不算
continue
}
if UFix64(rand_index) < item {
break
}
item_index = item_index + 1
}
let rand_nft = nft_list[item_index]
return rand_nft
}
这种场景更适用于链上实时、在线的生成随机NFT,特别是游戏场景,这样也显得更公平,更去中心化一些。
3 随机生成一个范围内的数值。这个主要是游戏相关的场景,还是以魔兽为例,好比一个武器的敏捷加成是22,具体生成的时候,实际是一个范围内,如[10,30]的随机值,而伤害值的上限和下限,一般也是一个范围内的随机值。
图4 产生一定范围内的随机数
还是从简单的说起,好比一个武器的敏捷加成是0到29之间的随机数, 如何设计?那就和场景1完全一样了,用内置函数生成的大随机数取 模 30即可,得到的就是0到29之间的随机数。
当然,一般为了安慰游戏玩家,武器的属性随机数不会从0开始,大部分还会给个鼓励奖,好比敏捷加成是10到39之间的随机数。可是我们只会生成0到29的随机数啊?那就把生成的[0, 29]之间的随机数,都加上10,看看是什么,不就是[10, 39]之间的随机数吗? 具体实现代码,就按照这个思路写就行,如果要生成[n,m]之间的随机数,那就先生成[n-n, m-n], 也就是[0,m-n]之间的随机数,然后再加n就行啦:)
什么?你想生成10.1到30.6之间的随机数?好吧,居然有小数位,这时候,就要发挥大家幼儿园数学全部功力了,那就先生成101到306之间的随机数,然后除以10好了!WOW 简直堪比潘周聃了。。。
具体的代码实现如下所示:
//功能:给定一个最大值和最小值,返回两个值区间内的一个随机值,本函数精度到3位小数,如果精度要求更好,可调整ratio即可
pub fun get_rand_value(min_value:UFix64, max_value:UFix64): UFix64 {
var value = 0.0
if min_value == max_value {
value = min_value
return value
}
let ratio = 1000.0
let dis = ratio*(max_value - min_value) //ensure max_value - min_value is more than 0.001
let big_int = unsafeRandom() //UInt64,can't run in playground, need testnet or emu
//let big_int:UInt64 = 999923
let base_mod = UInt64(dis + 1.0)
let rand_value = big_int % base_mod
let expand_value = ratio*min_value + UFix64(rand_value)
value = expand_value/ratio
return value
}
本节内容到此结束,眼过千遍,不如手过一遍,大家还是找点时间跑一下代码,才能学的更快。
思考一下
真实的魔兽世界等游戏,随机生成规则往往比上面说的稍微更复杂一些,典型的如不同稀有度/颜色的装备, 其属性随机范围也是不一样的,好比一把剑(sword), 颜色质量的生成概率如表1所示。剑的属性有damage/伤害、agility/敏捷、intelligence/智力3个属性,不同颜色的装备,具体的属性分布如下表所示:
装备颜色/稀有度 |
属性 |
属性值范围 |
白色(普通) |
damage/伤害 |
200.0,500.0 |
agility/敏捷 |
20.0, 40.0 |
|
intelligence/智力 |
10.0, 30.0 |
|
绿色(优秀) |
damage/伤害 |
500.0,1000.0 |
agility/敏捷 |
40.0, 80.0 |
|
intelligence/智力 |
30.0, 70.0 |
|
蓝色(精良) |
damage/伤害 |
1000.0,2000.0 |
agility/敏捷 |
80.0, 120.0 |
|
intelligence/智力 |
70.0, 110.0 |
|
紫色(史诗) |
damage/伤害 |
2000.0, 2600.0 |
agility/敏捷 |
120.0, 200.0 |
|
intelligence/智力 |
110.0, 190.0 |
|
橙色(传说) |
damage/伤害 |
3500.0, 3500.0 |
agility/敏捷 |
200.0, 400.0 |
|
intelligence/智力 |
190.0, 390.0 |
大家想想,基于上面的知识,如何实现上表中的内容?如果能自行实现这个,flow cadence 编程基本就略懂了。具体实现可以参考文末的github,当然,最好能自己先写一写。
另外,如果大家用flow的playground调试代码的时候,需要注意,playground是不支持运行UnsafeRandom函数的@#¥#@¥@,会报如下错误:
[Error Code: 1057] operation (UnsafeRandom) is not supported in this environment
已经和开发团队确认,目前就是这样的,大家playground调试的时候,可以先固定一个UInt64正整数,调试完成,再在虚拟机或者测试环境上调试即可。
在虚拟机调试的时候,需要注意,启动的时候设置区块生成时间-b参数:
flow emulator -b 1s
也就是1s产生一个区块,要不然的话,区块高度会一直停留在0。你UnsafeRandom生成的随机数一直不变@#@¥¥#....
题外话
flow Cadence的 unsafeRandom()是否 safe?如果是100% safe的话,官方应该叫safeRandom了吧。。。 主要问题,还是前面说的的,在一个区块内,生成随机数的会有碰撞问题,就是如果都用一个区块的高度、id等,使用一个算法生成一个大整数,这个大整数显然就是一样的。如果一个区块时间比较长,一个区块内“随机”的NFT可能就一样了。我们可以用一个简单的随机脚本来测试以下:
pub fun main():[UInt64]{
let my_block = getCurrentBlock()
var rlist: [UInt64] = [UInt64(my_block.height), UInt64(my_block.timestamp)]
var i = 0
while i< 2 {
rlist.append(unsafeRandom())
i = i + 1
}
return rlist //返回区块高度,区块时间,两个随机数
}
多次测试的结果如下所示:
区块高度/区块时间/第一个随机数/第二个随机数
69843020,1654499716,4970545721399468167,13510533599423613284
69843021,1654499717,9693390852741968751,2039449844162889432
69843022,1654499717,8214972371709431416,18405089478585935032
69843022,1654499717,8214972371709431416,18405089478585935032
基本也我们预期的差不多,不同区块内,unsafeRandom生成的随机数是不一样的。但一个区块内,函数的第一次调用,生成随机数是一样的,一个区块内的一个函数的多次调用,生成的随机数是不一样的。因为flow区块链的区块生成是1s左右,因此,如果是业务量不是那么大,好比一天mint几千个以内,使用unsafeRandom()生成随机数,问题不是很大。
当然,我们也可以参考以太坊常用的方法,把用户地址等业务数据加入到随机数生成中,这样就避免区块内的随机数碰撞问题。基于Cadence一个基本实现如下所示:
pub fun main(user_address:Address):UInt256{
let rand_int = unsafeRandom()
let rand_data: [UInt8] = rand_int.toBigEndianBytes() // is `[73, 150, 2, 210, ...]`
let tag = user_address.toString()
let data = HashAlgorithm.KECCAK_256.hashWithTag(rand_data, tag:tag) //[UInt8]
var data_int:UInt256 = 0
var data_len = UInt256(data.length)
//[UInt8] 转 UInt256
for item in data {
var ratio:UInt256 = 1
var i:UInt256 = 0
while (i<data_len-1) {
ratio = ratio*256
i = i + 1
}
data_int = data_int + UInt256(item)*ratio
data_len = data_len - 1
}
return data_int
}
加上用户地址之后,区块内的随机数碰撞问题也基本解决了。如果业务场景涉及利益不是特别大的情况下,好比一般的盲盒、NFT游戏场景,使用这种“区块随机数据+业务数据”的方式生成随机数,完全可以满足需求。
我们具体再看看,得到的随机数分布是不是符合我们的预期,我们还是用加用户地址生成随机数的函数,使用不同的账号,生成10000个0-9的随机数。
生成的0-9随机数,统计结果为:(数字,数量) [(0, 951), (1, 1005), (2, 1004), (3, 1047), (4, 987), (5, 1017), (6, 985), (7, 970), (8, 1038), (9, 996)]。数据统计分布如下图所示:
图5 生成0-9的随机数个数统计图
按照预期,每个数字应该是1000个左右,实际上生成的大致都是950个到1050个之间,数量误差不超过5%。还是基本符合预期的。
Playground: Flow Playground
Github:GitHub - maris205/flow-is-best: flow cadence learning code. from solidity to cadence