naming-Clarity Smart Contracts-C

FROM : https://docs.blockstack.org/core/smart/clarityref

Clarity的语言参考

这个文件包含了Clarity语言的引用。

• Block Properties

• Supported types
  • Int type
  • Bool type
  • Buffer type
  • List type
  • Principal type
  • Tuple type
  • Optional type
  • Response type
• Native variables
  • block-height
  • contract-name
  • tx-sender
• Clarity function reference
  • * (multiply)
  • + (add)
  • - (subtract)
  • / (divide)
  • < (less than)
  • <= (less than or equal)
  • > (greater than)
  • >= (greater than or equal)
  • and
  • as-contract
  • begin
  • contract-call!
  • default-to
  • define-data-var
  • define-map
  • define-public
  • define-read-only
  • define
  • delete-entry!
  • eq?
  • err
  • expects!
  • expects-err!
  • fetch-contract-entry
  • fetch-entry
  • fetch-var
  • filter
  • fold
  • get-block-info
  • get
  • hash160
  • if
  • insert-entry!
  • is-none?
  • is-ok?
  • keccak256
  • let
  • list
  • map
  • mod
  • not
  • ok
  • or
  • pow
  • print
  • set-entry!
  • set-var!
  • sha256
  • tuple
  • xor

block的属性

get-block-info函数获取指定块高度的块的属性详细信息。例如:

(get-block-info time 10) ;; Returns 1557860301

因为Clarity语言是预发布的，所以获取的块属性是从SQLite数据库中模拟的属性。可用的属性名称如下:

属性	定义
header-hash	包含块哈希的32字节缓冲区
burnchain-header-hash	一个32字节的缓冲区，包含刻录证明的散列。
vrf-seed	包含用于块的可验证随机函数(VRF)种子值的32字节缓冲区。
time	一个整数值，包含大致对应于块被挖掘时的值。这是一个Unix历元时间戳(以秒为单位)。

警告:
时间不会随着每个块单调地增加。block时间只在两小时内准确。更多信息请参见BIP113。

支持的类型

本节列出智能合约可用的类型。Clarity支持的惟一原子类型是布尔值、整数、固定长度缓冲区和主体。

Int类型

Clarity语言中的integer类型是一个16字节带符号整数，它允许指定单个栈传输中可使用的微栈的最大数量。使用get-block-info函数可以获得BlockHeightInt。

Bool类型

支持“真”或“假”的值。

Buffer类型

缓冲区类型表示固定长度的字节缓冲区。目前，构造缓冲区的唯一方法是使用字符串文字，例如“alice.id”或hash160 (“bob.id”)
所有哈希函数返回缓冲区:
hash160 sha256 keccak256

块属性head -hash、burnchain-head -hash和vrf-seed都是缓冲区。

List类型

Clarity支持原子类型列表。但是，语言中唯一的可变长度列表作为函数输入出现;不支持append或join之类的列表操作。

Principal类型

Clarity提供了这个原语，用于检查智能合约事务是否由特定的主体签署。主体表示支出实体，大致相当于堆栈地址。主体的签名不是由智能合约来检查的，而是由虚拟机来检查的。智能合约函数可以使用全局定义的tx-sender变量来获取当前主体。

智能合约也可以是主体(由智能合约的标识符表示)。但是，没有与智能合约相关联的私钥，并且它不能在区块链上广播已签名的事务。智能合约使用特殊的变量contract-name来引用它自己的主体。

Tuple类型

为了支持在键和值中使用命名字段，Clarity允许使用函数(tuple…)构造命名元组

(define imaginary-number-a (tuple (real 1) (i 2)))
(define imaginary-number-b (tuple (real 2) (i 3)))

这允许动态地创建命名元组，这对于键和值本身是命名元组的数据映射非常有用。在给定的映射中，使用以下方法设置或获取值:

功能	描述
(fetch-entry map-name key-tuple)	获取与映射中给定键关联的值，如果没有这样的值，则返回none。
(set-entry! map-name key-tuple value-tuple)	设置数据映射中键元组的值
(insert-entry! map-name key-tuple value-tuple)	当且仅当条目不存在时，设置数据映射中键元组的值。
(delete-entry! map-name key-tuple)	从数据映射中删除键元组。

要访问给定元组的指定值，函数(get name tuple)将从元组返回该项。

可选的类型

表示一个可选值。这用于替代其他语言中“null”值的典型用法，并表示可以是某个值或没有值的类型。可选类型用作数据映射函数的返回类型。

响应类型

响应类型表示公共函数的结果。使用此类型指示和返回与函数执行关联的数据。此外，响应应该指示函数是否出错(因此没有在数据库中具体化任何数据)或运行ok(在这种情况下，数据在数据库中具体化)。

响应类型包含两个子类型——ok事件中的响应类型(即，公共函数成功时返回整数代码)和err类型(即，函数错误时返回缓冲区)。

本地变量

Clarity语言包含可以在合约中使用的本地变量。

block-height

区块链中块的高度。块高度是链中任意给定块与区块链中第一个块之间的块数。您可以通过get-block-info函数获得块高度。

contract-name

表示当前合约。

tx-sender

表示当前主体。此变量合约调用期间不更改。这意味着，如果事务调用给定智能合约中的函数，该函数就能够代表您调用其他智能合约。这支持各种各样的应用程序，但是对于使用智能合约的用户来说，这也带来了一些危险。对Clarity合约的静态分析确保该语言允许客户端推断出给定的智能合约将调用哪些函数。好的客户端应该始终警告用户给定事务的任何潜在副作用。

Clarity函数引用

* (multiply)

Syntax (* i1 i2...)
输入类型：int, ...
输出类型：int
将一个变量的整数输入相乘并返回结果。在发生溢出时，引发运行时错误。

例子：

(* 2 3) ;; Returns 6
(* 5 2) ;; Returns 10
(* 2 2 2) ;; Returns 8

+ (add)

Syntax (+ i1 i2...)

输入：int, ...
输出：int
添加整数输入的变量数量并返回结果。在发生溢出时，引发运行时错误。

例子：
(+ 1 2 3) ;; Returns 6

- (subtract)

Syntax (- i1 i2...)
输入类型：int, ...
输出类型：int
减去整数输入的变量数并返回结果。在发生下溢时，引发运行时错误。
例子：

(- 2 1 1) ;; Returns 0
(- 0 3) ;; Returns -3

/ (divide)

Syntax (/ i1 i2...)
输入类型：int, ...
输出类型：int
Integer除以整数输入的变量数并返回结果。如果除法为零，则引发运行时错误。
例子：
(/ 2 3) ;; Returns 0
(/ 5 2) ;; Returns 2
(/ 4 2 2) ;; Returns 1

< (less than)

Syntax (< i1 i2)
输入类型：int, int
输出类型：bool
比较两个整数，如果i1小于i2返回true，否则返回false。

例子：

(< 1 2) ;; Returns 'true
(< 5 2) ;; Returns 'false

<= (less than or equal)

Syntax (<= i1 i2)
输入类型：int, int
输出类型：bool
比较两个整数，如果i1小于或等于i2，返回true，否则返回false。

例子：

(<= 1 1) ;; Returns 'true
(<= 5 2) ;; Returns 'false

> (greater than)

Syntax (> i1 i2)
输入类型：int, int
输出类型：bool
比较两个整数，如果i1大于i2，返回true，否则返回false。

例子：

(> 1 2) ;; Returns 'false
(> 5 2) ;; Returns 'true

>= (greater than or equal)

Syntax (>= i1 i2)
输入类型：int, int
输出类型：bool
比较两个整数，如果i1大于或等于i2，返回true，否则返回false。

例子：

(>= 1 1) ;; Returns 'true
(>= 5 2) ;; Returns 'true

and

Syntax (and b1 b2 ...)
输入参数：bool, ...
输出参数：bool
如果所有布尔输入都为真，则返回真。重要的是，提供的参数是按顺序和延迟计算的。延迟求值意味着，如果其中一个参数返回false，函数将短路，并且没有后续的参数被求值。

例子：

(and 'true 'false) ;; Returns 'false
(and (eq? (+ 1 2) 1) (eq? 4 4)) ;; Returns 'false
(and (eq? (+ 1 2) 3) (eq? 4 4)) ;; Returns 'true

as-contract

Syntax (as-contract expr)
输入类型：A
输出类型：A
as-contract函数将当前上下文的tx-sender值切换到合同的主体，并使用该上下文执行expr。它返回expr的结果值。
例子：

(as-contract (print tx-sender)) ;; Returns 'CTcontract.name

begin

Syntax (begin expr1 expr2 expr3 ... expr-last)

输入类型：AnyType, ... A
输出类型：A
begin函数计算它的每个输入表达式，返回最后一个这样的表达式的返回值。

例子：
(begin (+ 1 2) 4 5) ;; Returns 5

contract-call!

Syntax (contract-call! contract-name function-name arg0 arg1 ...)

输入参数：ContractName, PublicFunctionName, Arg0, ...
输出参数：Response(A,B)
contract-call !函数执行给定合约的给定公共函数。您可以不使用此函数来调用当前合约中定义的公共函数。如果公共函数返回err，则调用contract-call!导致的任何数据库更改被中止。如果函数返回ok，则发生数据库更改。

例子：

(contract-call! tokens transfer 'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR 19) ;; Returns (ok 1)

default-to

Syntax (default-to default-value option-value)
输入类型：A, Optional(A)
输出类型：A
default-to函数尝试“解包”第二个参数:如果参数是(some ...)选项，它将返回该选项的内部值。如果第二个参数是一个(none)值，default-to返回default-value的值。

例子：
(default-to 0 (get id (fetch-entry names-map (tuple (name "blockstack"))))) ;; Returns 1337
(default-to 0 (get id (fetch-entry names-map (tuple (name "non-existant"))))) ;; Returns 0

define-data-var

Syntax (define-data-var var-name type value)
输入类型：VarName, TypeDefinition, Value
输出类型：Not Applicable
define-data-var用于定义一个新的持久变量，以便在智能合约中使用。这些变量只能由当前智能合约中修改。

持久化变量由类型和值定义。

与其他类型的定义语句一样，define-data-var可能只在智能合约定义(即，则不能将define语句放在函数体的中间)。

例子：
(define-data-var size int 0)
(define (set-size (value int))
(set-var! size value))
(set-size 1)
(set-size 2)

define-map

Syntax (define-map map-name ((key-name-0 key-type-0) ...) ((val-name-0 val-type-0) ...))

输入类型：MapName, KeyTupleDefinition, MapTupleDefinition
输出类型：Not Applicable

定义映射用于定义一个新的数据地图，以便在智能合约中使用。这些Map只能通过当前的智能合约进行修改。

映射由键元组类型和值元组类型定义。这些是使用名称和类型对列表定义的，例如，键类型可能是((id int))，它是一个元组，具有一个int类型的“id”字段。

与其他类型的定义语句一样，定义映射只能在智能合约定义(即，则不能将define语句放在函数体的中间)。

例子：
(define-map squares ((x int)) ((square int)))
(define (add-entry (x int))
(insert-entry! squares ((x 2)) ((square (* x x)))))
(add-entry 1)
(add-entry 2)
(add-entry 3)
(add-entry 4)
(add-entry 5)

define-public

Syntax (define-public (function-name (arg-name-0 arg-type-0) (arg-name-1 arg-type-1) ...) function-body)

输入类型：MethodSignature, MethodBody
输出类型：Not Applicable
define-public用于为智能合约定义公共功能和事务。公共函数可以从其他智能合约调用，用户可以通过向blockstack提交事务直接调用它。

与其他类型的定义语句一样，define-public只能在智能合约中定义(即，则不能将define语句放在函数体的中间)。

公共函数必须返回一个ResponseType(使用ok或err)。如果函数返回一个err类型，则公共函数执行的任何datamap修改都将中止。其他合约可以通过合约调用调用公共函数!

例子：
(define-public (hello-world (input int))
(begin (print (+ 2 input))
(ok input)))

define-read-only

Syntax (define-read-only (function-name (arg-name-0 arg-type-0) (arg-name-1 arg-type-1) ...) function-body)

输入类型：MethodSignature, MethodBody
输出类型：Not Applicable

define-read-only用于为智能合约定义公共只读函数。这些功能可以从其他智能合约中调用。

与其他类型的定义语句一样，define-read-only可能只在智能合约定义(即，则不能将define语句放在函数体的中间)。

只读函数可以返回任何类型。但是，只读函数不能执行任何datamap修改，也不能调用任何执行此类修改的函数。这在类型检查期间和函数执行期间强制执行。其他合约可以通过合约调用调用公共只读函数!

例子：
(define-read-only (just-return-one-hundred)
(* 10 10))

define

Syntax (define (function-name (arg-name-0 arg-type-0) (arg-name-1 arg-type-1) ...) function-body)

输入类型：MethodSignature, MethodBody
输出类型：Not Applicable

define用于为智能合约定义私有函数。私有函数不能从其他智能合约调用，也不能由用户直接调用。相反，这些函数只能由同一智能合约中定义的其他函数调用。

与其他类型的定义语句一样，define只能在智能合约定义(即，则不能将define语句放在函数体的中间)。

私有函数可以返回任何类型。

例子：
(define (max-of (i1 int) (i2 int))
(if (> i1 i2)
i1
i2))
(max-of 4 6) ;; returns 6

delete-entry!

Syntax (delete-entry! map-name key-tuple)
输入类型：MapName, Tuple
输出类型：bool
delete-entry!函数删除与给定映射的输入键关联的值。如果一个项存在并被删除，函数返回true。如果数据映射中不存在此键的值，则函数返回false。
例子：
(delete-entry! names-map (tuple (name "blockstack"))) ;; Returns 'true
(delete-entry! names-map (tuple (name "blockstack"))) ;; Returns 'false
(delete-entry! names-map ((name "blockstack"))) ;; Same command, using a shorthand for constructing the tuple

eq?

Syntax (eq? v1 v2...)
输入类型：A, A, ...
输出类型：bool
比较输入的值，如果它们都相等，则返回true。注意，与(and…)函数不同，(eq?不会短路。

例子：
(eq? 1 1) ;; Returns 'true
(eq? 1 'false) ;; Returns 'false
(eq? "abc" 234 234) ;; Returns 'false

err

Syntax (err value)
输入类型：A
输出类型：Response(A,B)
err函数从输入值构造响应类型。使用err在公共函数中创建返回值。err值表示函数处理期间的任何数据库更改都应该回滚。

例子：
(err 'true) ;; Returns (err 'true)

expects!

Syntax (expects! option-input thrown-value)

输入类型：Optional(A) | Response(A,B), C
输出类型：A
expects!函数尝试“解包”第一个参数:如果参数是一个选项类型，并且参数是一个(some ...)选项，那么expect !返回该选项的内部值。如果参数是响应类型，并且参数是(ok…)响应，那么expect !返回ok的内部值。如果提供的参数是(err ...)或(none)值，那么expect !从当前函数返回thrown-value，并退出当前控制流。

例子：
(expects! (fetch-entry names-map (tuple (name "blockstack"))) (err 1)) ;; Returns (tuple (id 1337))

expects-err!

Syntax (expects-err! response-input thrown-value)
输入类型：Response(A,B), C
输出类型：B
expects-err !函数尝试“解压缩”第一个参数:如果参数是(err ...)响应，那么expect -err!返回err的内部值。如果提供的参数是一个(ok…)值，expect -err!从当前函数返回thrown-value，并退出当前控制流。
例子：
(expects-err! (err 1) 'false) ;; Returns 1

fetch-contract-entry

Syntax (fetch-contract-entry contract-name map-name key-tuple)
输入类型：ContractName, MapName, Tuple
输出类型：Optional(Tuple)

fetch-contract-entry函数查找并返回来自合约的条目，而不是当前合约的数据映射。使用键元组查找值。如果数据映射中没有与该键关联的值，则函数返回一个(none)选项。否则，它返回(某个值)。

例子：
(expects! (fetch-contract-entry names-contract names-map (tuple (name "blockstack")) (err 1))) ;; Returns (tuple (id 1337))
(expects! (fetch-contract-entry names-contract names-map ((name "blockstack")) (err 1)));; Same command, using a shorthand for constructing the tuple

fetch-entry

Syntax (fetch-entry map-name key-tuple)
输入类型：MapName, Tuple
输出类型：Optional(Tuple)

fetch-entry函数从合约的数据映射中查找并返回一个条目。使用键元组查找值。如果数据映射中没有与该键关联的值，则函数返回一个(none)选项。否则，它返回(某个值)

例子：
(expects! (fetch-entry names-map (tuple (name "blockstack"))) (err 1)) ;; Returns (tuple (id 1337))
(expects! (fetch-entry names-map ((name "blockstack"))) (err 1)) ;; Same command, using a shorthand for constructing the tuple

fetch-var

Syntax (fetch-var var-name)
输入类型：VarName
输出类型：A
fetch-var函数从合约的数据映射中查找并返回一个条目。使用var-name查找值。

例子：
(fetch-var cursor) ;; Returns cursor

filter

Syntax (filter func list)

输入类型：Function(A) -> bool, (list A)
输出类型：(list A)
filter函数将输入函数func应用于输入列表的每个元素，并返回相同的列表，其中删除了func返回false的任何元素。

例子：
(filter not (list true false true false)) ;; Returns (list false false)

fold

Syntax (fold func list initial-value)
输入类型：Function(A, B) -> B, (list A)
输出类型：B
fold函数将输入函数func应用于输入列表的每个元素以及之前应用fold函数的输出。在第一个list元素上调用时，它使用初值作为第二个输入。fold返回后续应用程序返回的最后一个值。

例子：
(fold * (list 2 2 2) 1) ;; Returns 8
(fold * (list 2 2 2) 0) ;; Returns 0

get-block-info

Syntax (get-block-info prop-name block-height-expr)
输入类型：BlockInfoPropertyName, BlockHeightInt
输出类型：buff | int
get-block-info函数获取给定块高度块的数据。返回的值和类型由指定的BlockInfoPropertyName确定。如果提供的块高度不对应于现有块，则函数将中止。当前可用的属性名称有time、head -hash、burnchain-head -hash和vrf-seed。

time属性返回块头时间字段的整数值。这是一个Unix历元时间戳(以秒为单位)，大致对应于块被挖掘的时间。警告:这不会随着每个块的增加而单调地增加，并且块的时间只能精确到两个小时内。更多信息请参见BIP113。

head -hash、burnchain-head -hash和vrf-seed属性返回一个32字节的缓冲区。

例子：
(get-block-info time 10) ;; Returns 1557860301
(get-block-info header-hash 2) ;; Returns 0x374708fff7719dd5979ec875d56cd2286f6d3cf7ec317a3b25632aab28ec37bb
(get-block-info vrf-seed 6) ;; Returns 0xf490de2920c8a35fabeb13208852aa28c76f9be9b03a4dd2b3c075f7a26923b4

get

Syntax (get key-name tuple)
输入类型：KeyName and Tuple | Optional(Tuple)
输出类型：AnyType
get函数从提供的类型化元组获取与给定键关联的值。如果以可选值作为输入的元组提供，get返回元组中指定键的可选类型。如果提供的选项是(none)选项，则获取返回(none)。

例子：
(get id (tuple (name "blockstack") (id 1337))) ;; Returns 1337
(get id (fetch-entry names-map (tuple (name "blockstack")))) ;; Returns (some 1337)
(get id (fetch-entry names-map (tuple (name "non-existent")))) ;; Returns (none)

hash160

Syntax (hash160 value)
输入类型：buff|int
输出类型：(buff 20)
hash160函数计算输入值的RIPEMD160(SHA256(x))。如果提供一个整数(128位)，则通过该整数的little-endian表示形式计算散列。

例子：
(hash160 0) ;; Returns 0xe4352f72356db555721651aa612e00379167b30f

if

Syntax (if bool1 expr1 expr2)
输入类型：bool, A, A
输出类型：A
if函数接受一个布尔参数和两个必须返回相同类型的表达式。如果布尔输入为真，if函数将计算并返回expr1。如果布尔输入为false, If函数将计算并返回expr2。

例子：
(if true 1 2) ;; Returns 1
(if (> 1 2) 1 2) ;; Returns 2

insert-entry !

Syntax (insert-entry! map-name key-tuple value-tuple)

输入类型：MapName, TupleA, TupleB
输出类型：bool

例子：
(insert-entry! names-map (tuple (name "blockstack")) (tuple (id 1337))) ;; Returns 'true
(insert-entry! names-map (tuple (name "blockstack")) (tuple (id 1337))) ;; Returns 'false
(insert-entry! names-map ((name "blockstack")) ((id 1337))) ;; Same command, using a shorthand for constructing the tuple

is-none?

Syntax (is-none? value)
输入类型：Optional(A)
输出类型：bool

s-none?测试提供的选项值，如果选项值为(none)返回true，如果为(some…)返回false。

例子：
(is-none? (get id (fetch-entry names-map (tuple (name "blockstack"))))) ;; Returns 'false
(is-none? (get id (fetch-entry names-map (tuple (name "non-existant"))))) ;; Returns 'true

is-ok?

Syntax (is-ok? value)

输入类型：Response(A,B)
输出类型：bool
is-ok? 测试提供的响应值，如果响应ok，返回true;如果响应是err，返回false。

例子：
(is-ok? (ok 1)) ;; Returns 'true
(is-ok? (err 1)) ;; Returns 'false

keccak256

Syntax (keccak256 value)
输入类型：buff|int
输出类型：(buff 32)
keccak256函数计算输入值的keccak256(值)。注意，这与NIST SHA-3(即FIPS 202)标准不同。如果提供一个整数(128位)，则通过该整数的little-endian表示形式计算散列。
例子：
(keccak256 0) ;; Returns 0xf490de2920c8a35fabeb13208852aa28c76f9be9b03a4dd2b3c075f7a26923b4

let

Syntax (let ((name1 expr1) (name2 expr2) ...) expr-body)

输入类型：((name2 AnyType) (name2 AnyType) ...), A
输出类型：A
let函数接受变量名和表达式对的列表，计算每个表达式并将其绑定到相应的变量名。由这组绑定创建的上下文用于评估和返回expr-body的值。

例子：
(let ((a 2) (b (+ 5 6 7))) (+ a b)) ;; Returns 20

list

Syntax (list expr1 expr2 expr3 ...)
输入参数：A, ...
输出参数：(list A)
list函数构造一个由输入值组成的列表。所提供的每个值必须具有相同的类型。

例子：
(list (+ 1 2) 4 5) ;; Returns [3 4 5]

map

Syntax (map func list)
输入类型：Function(A) -> B, (list A)
输出类型：(list B)
map函数将输入函数func应用于输入列表的每个元素，并输出包含这些函数应用程序的输出的列表。

例子：
(map not (list true false true false)) ;; Returns 'false true false true

mod

Syntax (mod i1 i2)

输入类型：int, int
输出类型：int
返回整数除以i1除以i2得到的整数余数。如果除法为零，则引发运行时错误。

例子：
(mod 2 3) ;; Returns 0
(mod 5 2) ;; Returns 1
(mod 7 1) ;; Returns 0

not

Syntax (not b1)
输入类型：bool
输出类型：bool
返回布尔输入的倒数。

例子：
(not 'true) ;; Returns 'false
(not (eq? 1 2)) ;; Returns 'true

ok

Syntax (ok value)
输入类型：A
输出类型：Response(A,B)

ok函数从输入值构造响应类型。使用ok在公共函数中创建返回值。ok值表示函数处理期间的任何数据库更改都应该实现。

例子：
(ok 1) ;; Returns (ok 1)

or

Syntax (or b1 b2 ...)
输入类型：bool, ...
输出类型：bool

如果任何布尔输入为真，则返回真。重要的是，提供的参数是按顺序和延迟计算的。延迟求值意味着，如果其中一个参数返回false，函数将短路，并且没有后续的参数被求值。

例子：
(or 'true 'false) ;; Returns 'true
(or (eq? (+ 1 2) 1) (eq? 4 4)) ;; Returns 'true
(or (eq? (+ 1 2) 1) (eq? 3 4)) ;; Returns 'false
(or (eq? (+ 1 2) 3) (eq? 4 4)) ;; Returns 'true

pow

Syntax (pow i1 i2)
输入类型：int, int
输出类型：int
返回i1的i2次方的结果。在发生溢出时，引发运行时错误。

例子：
(pow 2 3) ;; Returns 8
(pow 2 2) ;; Returns 4
(pow 7 1) ;; Returns 7

print

Syntax (print expr)
输入类型：A
输出类型：A
print函数计算并返回其输入表达式。在为开发配置的块堆栈核心节点(与生产挖掘节点相反)上，此函数将结果值打印到STDOUT(标准输出)。

例子：
(print (+ 1 2 3)) ;; Returns 6

set-entry!

Syntax (set-entry! map-name key-tuple value-tuple)
输入类型：MapName, TupleA, TupleB
set-entry !函数将与输入键关联的值设置为输入值。此函数执行盲更新;无论值是否已经与键关联，函数都会覆盖该现有关联。

例子：
(set-entry! names-map (tuple (name "blockstack")) (tuple (id 1337))) ;; Returns 'true
(set-entry! names-map ((name "blockstack")) ((id 1337))) ;; Same command, using a shorthand for constructing the tuple

set-var!

Syntax (set-var! var-name expr1)

输入参数：VarName, AnyType
输出参数：bool

set-var !函数将与输入变量关联的值设置为输入值。

例子：
(set-var! cursor (+ cursor 1)) ;; Returns 'true

sha256

Syntax (sha256 value)
输入类型：buff|int
输出类型：(buff 32)

sha256函数计算输入值的sha256 (x)。如果提供一个整数(128位)，则通过该整数的little-endian表示形式计算散列。

例子：
(sha256 0) ;; Returns 0x374708fff7719dd5979ec875d56cd2286f6d3cf7ec317a3b25632aab28ec37bb

tuple

Syntax (tuple ((key0 expr0) (key1 expr1) ...))
输入类型：(list (KeyName AnyType))
输出类型：Tuple
tuple函数从提供的键和表达式对构造类型化元组。get函数可以使用类型化元组作为输入，从给定的元组中选择特定的值。键名不能在同一个元组定义中出现多次。对提供的表达式求值并与表达式的配对键名关联。

例子：
(tuple (name "blockstack") (id 1337))

xor

Syntax (xor i1 i2)

输入类型：int, int
输出类型：int
返回按位排他或' i1与i2 'ing的结果。

例子：
(xor 1 2) ;; Returns 3
(xor 120 280) ;; Returns 352