BEPs协议：BUMO STO 10 协议

2019-04-30 09:50:52 阅读：315 来源： 互联网

标签：10 tranche STO value Token params input BEPs method

BUMO STO 10 协议

简介

STO 10 (Security Token Standard)是指基于 BUMO 智能合约发行证券型 token 的标准协议。该标准在 CTP 10 的基础上制定了增发 token，销毁 token，存储相关法律文件，将 token进行分片 ( tranche )，为 tranche 设置锁定期等约束条件，允许将指定 tranche 的 token 授权给第三方操作人，添加控制者 ( 如监控部门 ) 的相关功能。

目标

基于该协议标准发行的 token，能够在任何司法管辖区内发行和管理，并能够符合相关的监管限制。

规则

BUMO 智能合约由 JavaScript 语言实现, 包含初始化函数 init 和两个入口函数 main、query 。init 函数用于合约创建时初始化，main 函数主要负责数据写入，query 函数负责数据查询。

STO 属性

Token 基本信息

key: global_attribute
value: {
    "version": "1.0",
    "name": "Security Token",
    "symbol": "STO",
    "decimals": 8,
    "totalSupply": "100000",
    "scheduledTotalSupply":"100000",
    "owner":""
}

version: 版本
name: Token 名称
symbol: Token 符号
decimals: Token 精度
totalSupply: Token 已发行总量，其值等于 10^decimals已发行量。假如,当前已发行总量是 10000, 精度为 8的 token，totalSupply = 10 ^ 8 * 10000, 结果是 1000000000000。*
scheduledTotalSupply: Token 计划发行的总量, 0 表示不限制发行量，大于 0 表示限制发行总量。其值等于10^decimals计划发行量。假如,计划要发行总量是 10000, 精度为 8 的 Token，scheduledTotalSuppl = 10 ^ 8 * 10000, 结果是 1000000000000。*
owner: Token 所有权拥有者

Tranche 属性及限制

key: tranche_attribute_id
value: {
    "description": "private",
    "limits": [{
        "name": "lockupPeriod",
        "value": "1517470155872949",
    },
    ……
    ]
}

id: tranche 的 id
description: tranche 的描述信息
limits: 约束
name: 约束名称
value: 约束内容

所有 tranche 余额总和

key: balance_tokenHolder
value: {
    "value": "100000000", 
    "tranches": ["0", "1",……]
}

tokenHolder: Token 持有人
value: 余额总数
tranches: trancheId 列表

Tranche 余额

key: tranche_tokenHolder_id
value: "10000"

tokenHolder: Token 持有人
id: trancheId
value: tranche 余额总量

操作者

key: operator_tokenHolder_operatorAddress
value: ["0", "1", ……]

tokenHolder: Token 持有人
operatorAddress: 操作者地址
tranches: trancheId 列表, 空列表表示授权所有分片，非空列表表示授权到指定的分片

控制者

key: global_controller
value: [address1, addres2, ...]

controllers: 控制者列表
address: 控制者地址

授权

key: allowance_tokenHolder_tranche_spenderAddress
value: "1000"

tokenHolder: Token 持有人
tranche: 指定 trancheId
spenderAddress: 被授权的账户地址
value: 授权数量

文档

key: document_documentName
value: {
    "url": "https://BUMO.io/BUMO-Technology-White-Paper-cn",
    "hashType": "sha256",
    "documentHash": "ad67d57ae19de8068dbcd47282146bd553fe9f684c57c8c114453863ee41abc3",
    "provider": "buQXRbzyDaVpX3JT3Wd2gj2U2ZzVWZRpwcng",
    "date": 1544595438978280
}

documentName: 文档名称
url: 文档链接地址
hashType: 哈希类型
documentHash: 哈希的 16 进制字符串
provider: 文档提供者
data: 提供日期

事件

函数setDocument、createTranche、transferWithData、transferFromWithData、transferFromToTranche、transferTranche、transferToTranche、transfersToTranche、controllerTransfer、controllerRedeem、authorizeOperator、revokeOperator、authorizeOperatorForTranche、revokeOperatorForTranche、operatorTransferTranche、operatorRedeemTranche、issue、issueToTranche、redeem、redeemFrom、redeemTranche、redeemFromTranche、transfer、approve、approveTranche、transferFrom会触发事件，事件是调用tlog接口，在区块链上记录一条交易日志，该日志记录了函数调用详情，方便用户阅读。

tlog定义如下:

tlog(topic,args...);

tlog会产生一笔交易写在区块上
topic: 日志主题，必须为字符串类型,参数长度(0,128]
args...: 最多可以包含5个参数，参数类型可以是字符串、数值或者布尔类型,每个参数长度(0,1024]

功能函数

BUMO ATP 20 协议中的函数包括tokenInfo、setDocument、getDocument、createTranche、balanceOf、balanceOfTranche、tranchesOf、transferWithData、transferFromToTranche、transferTranche、transferToTranche、transfersToTranche、isControllable、controllerTransfer、controllerRedeem、authorizeOperator、revokeOperator、authorizeOperatorForTranche、revokeOperatorForTranche、isOperator、isOperatorForTranche、operatorTransferTranche、operatorRedeemTranche、isIssuable、issue、issueToTranche、redeem、redeemFrom、redeemTranche、redeemFromTranche、canTransfer、canTransferTranche、canTransferToTranche、transfer、transferFrom、approve、approveTranche、allowance、allowanceForTranche。

tokenInfo

功能

查询 token 详情。
入口函数

query
参数
```
{
    "method": "tokenInfo
}
```

返回值

{
    "result":{
        "type": "string",
        "value": {
            "tokenInfo": {
                "name": "DemoToken",
                "symbol": "STP",
                "decimals": 8,
                "totalSupply": "10000000",
                "scheduledTotalSupply": "10000000",
                "owner": "buQXRbzyDaVpX3JT3Wd2gj2U2ZzVWZRpwcng",
                "version": "1.0"
            }
        }
    }
}

setDocument

注意：仅限于 token 的所有权拥有人和控制者使用。

功能

设置法律文件或其他参考资料
入口函数

main

参数

{
    "method":"setDocument",
    "params":{
        "name": "BUMO-Technology-White-Paper-cn",
        "url": "https://BUMO.io/BUMO-Technology-White-Paper-cn",
        "hashType": "sha256",
        "documentHash": "ad67d57ae19de8068dbcd47282146bd553fe9f684c57c8c114453863ee41abc3"
    }
}
- name: 文档名称，长度范围[1,256]
- url: 文档在线链接地址，长度范围[10,128k]
- hashType: 计算文档哈希的类型，长度范围[1,16]
- documentHash: 文档哈希的16进制字符串

返回值

成功：true

失败：抛出异常
事件
```
tlog('setDocument', sender, name, url, hashType, documentHash);
```
topic: 方法名，这里是 'setDocument'

sender: 合约调用账户地址

name: 文档名称

url: 文档在线链接地址

hashType: 哈希类型

documentHash: 哈希16进制字符串

getDocument

功能

查询法律文件或其他参考资料
入口函数

query

参数

{
    "method":"getDocument",
    "params":{
        "name": "BUMO-Technology-White-Paper-cn"
    }
}
- name: 文档名称

返回值

{
    "result": {
        "type": "string",
        "value": {
            "document": {
                "url": "https://BUMO.io/BUMO-Technology-White-Paper-cn",
                "hashType": "sha256",
                "documentHash": "ad67d57ae19de8068dbcd47282146bd553fe9f684c57c8c114453863ee41abc3",
                "provider": "buQXRbzyDaVpX3JT3Wd2gj2U2ZzVWZRpwcng",
                "date": 1544595438978280
            }
        }
    }
}
- url: 文档在线链接地址
- hashType: 计算哈希的方式
- documentHash: 哈希的 16 进制字符串
- provider: 文档提供者
- date: 上传日期

createTranche

注意：仅限于 token 的所有权拥有者使用。

功能

创建分支(只允许发行人操作)。
入口函数

main

参数

{
    "method":"createTranche",
    "params":{
        "tranche":{
            "id": "1",
            "description": "private",
            "limits":[{
                "name":"lockupPeriod",
                "value":"1517470155872949"
            }],
            "tokenHolders":{
                "buQoqGbz7o6RSkDympf8LrqSe8z4QkiBjcHw": "1000",
                ...
            }
        }
    }
}
- id: trancheid，大小范围[1,2^63-1]
- description: tranche 描述，长度范围[1,64k]
- limits: 约束条件
- name: 约束名称，长度范围[1,64]
- value: 约束内容，长度范围[1,256]
- tokenHolders: 分发的账户列表，最多支持8个

注意: 最多只允许分配给8个 tokenHolders

返回值

成功：true

失败：抛出异常
事件
```
tlog('createTranche', sender, id, description, limits, tokenHolders);
```
topic: 方法名，这里是 'createTranche'

sender: 合约调用账户地址

id: trancheid

description: tranche描述

limits: 约束条件, json 字符串

tokenHolders: 分发的账户列表, json 字符串

balanceOf

功能

查询指定账户下的所有 tranche 的 token 总和。
入口函数

query

参数

{
    "method": "balanceOfTranche",
    "params":{
        "address": "buQnTmK9iBFHyG2oLce7vcejPQ1g5xLVycsj"
    }
}

返回值

{
    "result": {
        "type": "string",
        "value": {
            "balance": "0.01"
        }
    }
}

balanceOfTranche

功能

查询指定账户下的指定 tranche 的 token 余额
入口函数

query

参数

{
    "method":"balanceOfTranche",
    "params":{
        "tranche": "1",
        "address": "buQZW68otiwmNPgzcBceuQ7NzFLX46FVyh65"
    }
}

返回值

{
    "result": {
        "type": "string",
        "value": {
            "balance": "1000"
        }
    }
}

tranchesOf

功能

查询与特定 token 持有者地址关联的所有 tranche 数量
入口函数

query

参数

{
    "method":"tranchesOf",
    "params":{
        "address": "buQZW68otiwmNPgzcBceuQ7NzFLX46FVyh65"
    }
}

返回值

{
    "result": {
        "type": "string",
        "value": {
            "balance": "30000"
        }
    }
}

transferWithData

功能

将合约触发者的 token 转移给目标账户，并允许携带任意数据。
入口函数

main

参数

{
    "method": "transferWithData",
    "params":{
        "to": "buQoP2eRymAcUm3uvWgQ8RnjtrSnXBXfAzsV",
        "value": "100",
        "data": ""
    }
}

- to: Token 收入方地址
- value: Token 数量，大小范围[0,2^63-1]
- data: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。长度范围[0,128k]

返回值

成功：true

失败：抛出异常
事件
```
tlog('transferWithData', sender, to, value, data);
```
topic: 方法名，这里是 'transferWithData'

sender: 合约调用账户地址

to: 目标账户地址

value: 转移数量(字符串类型)

data: 附加信息

transferFromWithData

功能

将指定 token 持有人的 token 转移给目标账户(合约触发者必须被授予足够的份额)，并允许携带任意数据。
入口函数

main

参数

{
    "method": "transferFromWithData",
    "params":{
        "from": "buQnTmK9iBFHyG2oLce7vcejPQ1g5xLVycsj",
        "to": "buQoP2eRymAcUm3uvWgQ8RnjtrSnXBXfAzsV",
        "value": "100",
        "data": ""
    }
}
- from: Token 支出方地址
- to: Token 收入方地址
- value: Token 数量，大小范围[0,2^63-1]
- data: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。长度范围[0,128k]

返回值

成功：true

失败：抛出异常
事件
```
  tlog('transferFromWithData', sender, from, to, value, data);
```
topic: 方法名，这里是 'transferFromWithData'

sender: 合约调用账户地址

from: Token 支出方地址

to: 目标账户地址

value: 转移数量(字符串类型)

data: 附加信息

transferFromToTranche

功能

将指定 token 持有人的指定 tranche 的 token 转移给目标账户，并允许携带任意数据。
入口函数

main

参数

{
    "method": "transferFromToTranche",
    "params":{
        "from": "buQm44k6VxqyLM8gQ7bJ49tJSjArhFsrVUKY",
        "fromTranche": "0",
        "to": "buQoP2eRymAcUm3uvWgQ8RnjtrSnXBXfAzsV",
        "toTranche": "1",
        "value": "100",
        "data": ""
    }
}
- from: Token 支出方地址
- fromTranche: Token 支出方 tranche 的 id，大小范围[0,2^63-1]
- to: Token 收入方地址
- toTranche: Token 收入方 tranche 的 id，大小范围[0,2^63-1]
- value: Token 数量，大小范围[0,2^63-1]
- data: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。长度范围[0,128k]

返回值

成功：true

失败：抛出异常
事件
```
tlog('transferFromToTranche', sender, from + '_' + fromTranche, to + '_' + toTranche, value, data);
```
topic: 方法名，这里是 'transferFromToTranche'

sender: 合约调用账户地址

from: Token 支出方地址

fromTranche: Token 支出方 tranche 的 id

to: Token 收入方地址

toTranche: Token 收入方 tranche 的 id

value: Token 数量

data: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。

transferTranche

功能

将合约触发者的指定 tranche 的 token 转移给目标账户的指定 tranche，并允许携带任意数据。
入口函数

main

参数

{
    "method": "transferTranche",
    "params":{
        "tranche": "0",
        "to": "buQoP2eRymAcUm3uvWgQ8RnjtrSnXBXfAzsV",
        "value": "100",
        "data": ""
    }
}
- tranche: Token 支出方和收入方 tranche 的 id，大小范围[0,2^63-1]
- to: Token 收入方地址
- value: Token 数量，大小范围[0,2^63-1]
- data: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。长度范围[0,128k]

返回值

成功：true

失败：抛出异常
事件
```
tlog('transferTranche', sender, tranche, to, value, data);
```
topic: 方法名，这里是 'transferTranche'

sender: 合约调用账户地址

tranche: tranche的id

to: Token 收入方地址

value: Token 数量

data: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。

transferToTranche

功能

将合约触发者的指定 tranche 的 token 转移给目标账户的指定 tranche，并允许携带任意数据。
入口函数

main

参数

{
    "method": "transferToTranche",
    "params":{
        "fromTranche": "0",
        "to": "buQoP2eRymAcUm3uvWgQ8RnjtrSnXBXfAzsV",
        "toTranche": "1",
        "value": "100",
        "data": ""
    }
}
- fromTranche: Token 支出方 tranche 的 id，大小范围[0,2^63-1]
- to: Token 收入方地址
- toTranche: Token 收入方 tranche 的 id，大小范围[0,2^63-1]
- value: Token 数量，大小范围[0,2^63-1]
- data: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。长度范围[0,128k]

返回值

成功：true

失败：抛出异常
事件
```
tlog('transferToTranche', sender, fromTranche, to + '_' + toTranche, value, data);
```
topic: 方法名，这里是 'transferToTranche'

sender: 合约调用账户地址

fromTranche: Token 支出方 tranche 的 id

to: Token 收入方地址

toTranche: Token 收入方 tranche 的 id

value: Token 数量

data: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。

transfersToTranche

功能

将合约触发者的指定的 tranche 的 token 转移给多个目标账户的某个 tranche，并允许携带任意数据。
入口函数

main

参数

{
    "method": "transfersToTranche",
    "params":{
        "fromTranche": "0",
        "toTranche": "1",
        "tokenHolders": {
            Address1: value1,
            Address2: value2,
             …
        },
        "data": ""
    }
}
- fromTranche: Token 支出方 tranche 的 id，大小范围[0,2^63-1]
- toTranche: Token 收入方 tranche 的 id，大小范围[0,2^63-1]
- tokenHolders: Token 收入方列表
- Address1/Address2/...: Token 收入方地址
- value1/value2/...: Token 转出数量，大小范围[0,2^63-1]
- data: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。长度范围[0,128k]

返回值

成功：返回目标账户的 tranche

失败：抛出异常
事件
```
tlog('transfersToTranche', sender, fromTranche, toTranche, tokenHolders, data);
```
topic: 方法名，这里是 'transfersToTranche'

sender: 合约调用账户地址

fromTranche: Token 支出方 tranche 的 id

tokenHolders: Token 收入方列表，json字符串

toTranche: Token 收入方 tranche 的 id

data: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。

isControllable

注意：如果 isControllable 是 true,那么 controller 在不需要授权的情况下，可以使用 operatorTransferTranche 和 operatorRedeemTranche 。

功能

判断当前 token 是否是可控制的，是否可由司法/指定账户(不需要授权)控制两个账户之间的流通。
入口函数

query
参数
```
{
    "method": "isControllable"
}
```
返回值

成功: true

失败: false

controllerTransfer

注意：在某些法域中，发行人（或由发行人委托的实体）可能需要保留强制转移 token 的能力。这可能是为了解决法律纠纷或法院命令，或补救投资者失去访问他们的私钥。

功能

允许授权的地址在任何两个令牌持有者之间传递 token。
入口函数

main

参数

{
    "method": "controllerTransfer",
    "params":{
        "from": "buQnTmK9iBFHyG2oLce7vcejPQ1g5xLVycsj",
        "fromTranche": "1",
        "to": "buQoP2eRymAcUm3uvWgQ8RnjtrSnXBXfAzsV",
        "toTranche": "2",
        "value": "100",
        "data": "",
        "operatorData": ""
    }
}
- from: Token 支出方地址
- fromTranche: Token 支出方 tranche 的 id，大小范围[0,2^63-1]
- to: Token 收入方地址
- toTranche: Token 收入方 tranche 的 id，大小范围[0,2^63-1]
- value: Token 数量，大小范围[0,2^63-1]
- data: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。长度范围[0,64k]
- operatorData: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。长度范围[0,64k]

返回值

成功: true

失败: 抛出异常
事件
```
tlog('controllerTransfer', sender, from + '_' + fromTranche, to + '_' + toTranche, value, data + "; " + operatorData);
```
topic: 方法名，这里是 'controllerTransfer'

sender: 合约调用账户地址

from: Token 支出方地址

fromTranche: Token 支出方 tranche 的 id

to: Token 收入方地址

toTranche: Token 收入方 tranche 的 id

value: Token 数量

data: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。

operatorData: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。

controllerRedeem

注意：在某些法域中，发行人（或由发行人委托的实体）可能需要保留强制转移 token的能力。这可能是为了解决法律纠纷或法院命令，或补救投资者失去访问他们的私钥。

功能

允许授权的地址为任何Token持有者赎回 token。
入口函数

main

参数

{
    "method": "controllerRedeem",
    "params":{
        "tokenHolder": "buQnTmK9iBFHyG2oLce7vcejPQ1g5xLVycsj",
        "tranche": "1",
        "value": "100",
        "data": "",
        "operatorData": ""
    }
}

data: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是签名数据（例如，动态白名单），但是足够灵活以适应其他用例。

返回值

成功: true

失败: 抛出异常
事件
```
tlog('controllerRedeem', sender, tokenHolder, tranche, value, data);
```
topic: 方法名，这里是 'controllerRedeem'

sender: 合约调用账户地址

tokenHolder: Token 持有人地址

tranche: Tranche 的 id

value: Token 数量

data: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。

authorizeOperator

功能

对合约触发者的所有 tranche 授权一个操作者。
入口函数

main

参数

{
    "method": "authorizeOperator",
    "params":{
        "operator": "buQnTmK9iBFHyG2oLce7vcejPQ1g5xLVycsj"
    }
}

返回值

成功: true

失败: 抛出异常
事件
```
tlog('authorizeOperator', sender, operator);
```
topic: 方法名，这里是 'authorizeOperator'

sender: 合约调用账户地址

operator: 操作人

revokeOperator

功能

撤消对之前合约触发者的所有 tranche 的操作者的授权。
入口函数

main

参数

{
    "method": "revokeOperator",
    "params":{
        "operator": "buQnTmK9iBFHyG2oLce7vcejPQ1g5xLVycsj"
    }
}

返回值

成功: true

失败: 抛出异常
事件
```
tlog('revokeOperator', sender, operator);
```
topic: 方法名，这里是 'revokeOperator'

sender: 合约调用账户地址

operator: 操作人

authorizeOperatorForTranche

功能

对合约触发者的指定 tranche 授权一个操作者。
入口函数

main

参数

{
    "method": "authorizeOperatorForTranche",
    "params":{
        "tranche": "1",
        "operator": "buQnTmK9iBFHyG2oLce7vcejPQ1g5xLVycsj"
    }
}

返回值

成功: true

失败: 抛出异常
事件
```
tlog('authorizeOperatorForTranche', sender, tranche, operator);
```
topic: 方法名，这里是 'authorizeOperatorForTranche'

sender: 合约调用账户地址

tranche: Tranche 的 id

operator: 操作人

revokeOperatorForTranche

功能

撤消对之前合约触发者的指定 tranche 的操作者的授权。
入口函数

main

参数

{
    "method": "revokeOperatorForTranche",
    "params":{
        "tranche": "1",
        "operator": "buQnTmK9iBFHyG2oLce7vcejPQ1g5xLVycsj"
    }
}

返回值

成功: true

失败: 抛出异常
事件
```
tlog('revokeOperatorForTranche', sender, tranche, operator);
```
topic: 方法名，这里是 'revokeOperatorForTranche'

sender: 合约调用账户地址

tranche: Tranche 的 id

operator: 操作人

isOperator

功能

判断是否是 token 持有人的所有 tranche 的操作人。
入口函数

query

参数

{
    "method": "isOperator",
    "params":{
        "operator": "buQnTmK9iBFHyG2oLce7vcejPQ1g5xLVycsj",
        "tokenHolder": "buQoP2eRymAcUm3uvWgQ8RnjtrSnXBXfAzsV"
    }
}

返回值

成功: true

失败: false

isOperatorForTranche

功能

判断是否是 token 持有人的指定 tranche 的操作人。
入口函数

query

参数

{
    "method": "isOperatorForTranche",
    "params":{
        "tranche": "1",
        "operator": "buQnTmK9iBFHyG2oLce7vcejPQ1g5xLVycsj",
        "tokenHolder": "buQoP2eRymAcUm3uvWgQ8RnjtrSnXBXfAzsV"
    }
}

返回值

成功: true

失败: false

operatorTransferTranche

功能

允许操作员代表 token 持有者在指定分段内转移 token。
入口函数

main

参数

{
    "method": "operatorTransferTranche",
    "params":{
        "tranche": "1",
        "from": "buQnTmK9iBFHyG2oLce7vcejPQ1g5xLVycsj",
        "to": "buQoP2eRymAcUm3uvWgQ8RnjtrSnXBXfAzsV",
        "value": "100",
        "data": "",
        "operatorData": ""
    }
}

返回值

成功：true

失败：抛出异常
事件
```
tlog('operatorTransferTranche', sender, tranche, from, to, value, data + '; ' + operatorData);
```
topic: 方法名，这里是 'operatorTransferTranche'

sender: 合约调用账户地址

tranche: Tranche 的 id

from: Token 支出方地址

to: Token 收入方地址

value: Token 数量

data: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。

operatorData: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。

operatorRedeemTranche

功能

允许操作员代表 token 持有者在指定分段内赎回 token（token 总量会减少）。
入口函数

main

参数

{
    "method": "operatorRedeemTranche",
    "params":{
        "tranche": "1",
        "tokenHolder": "buQoP2eRymAcUm3uvWgQ8RnjtrSnXBXfAzsV",
        "value": "100",
        "operatorData": ""
    }
}

返回值

成功：true

失败：抛出异常
事件
```
tlog('operatorRedeemTranche', sender, tranche, tokenHolder, value, operatorData);
```
topic: 方法名，这里是 'operatorRedeemTranche'

sender: 合约调用账户地址

tranche: Tranche 的 id

tokenHolder: Token 持有人

value: Token 数量

operatorData: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。

isIssuable

功能

证券 token 发行者可以指定发行完成了 token（即没有新的 token 可以被铸造或发行）。
入口函数

query
参数
```
{
    "method": "isIssuable"
}
```
返回值

成功: true

失败: false

issue

功能

增加指定 token 持有人的总供给量。
入口函数

main

参数

{
    "method": "issue",
    "params":{
        "tokenHolder": "buQoP2eRymAcUm3uvWgQ8RnjtrSnXBXfAzsV",
        "nowSupply": "1000000000000",
        "data": ""
    }
}

返回值

成功: true

失败: 抛出异常
事件
```
tlog('issue', sender, tokenHolder, nowSupply, data);
```
topic: 方法名，这里是 'issue'

sender: 合约调用账户地址

tokenHolder: Token 持有人

nowSupply: 当前的发行量

data: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。

issueToTranche

功能

增加指定 token 持有人的指定 tranche 的供给量。
入口函数

main

参数

{
    "method": "issueToTranche",
    "params":{
        "tranche": "",
        "tokenHolder": "buQoP2eRymAcUm3uvWgQ8RnjtrSnXBXfAzsV",
        "nowSupply": "1000000000000",
        "data": ""
    }
}

返回值

成功: true

失败: 抛出异常
事件
```
tlog('issueToTranche', sender, tranche, tokenHolder, nowSupply, data);
```
topic: 方法名，这里是 'issueToTranche'

sender: 合约调用账户地址

tranche: Tranche 的 id

tokenHolder: Token 持有人

nowSupply: 当前的发行量

data: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。

redeem

功能

从合约触发者赎回指定量的 token (总供给量会减少)。
入口函数

main

参数

{
    "method": "redeem",
    "params":{
        "value": "1000000000000",
        "data": ""
    }
}

返回值

成功: true

失败: 抛出异常
事件
```
tlog('redeem', sender, value, data);
```
topic: 方法名，这里是 'redeem'

sender: 合约调用账户地址

value: 赎回的数量

data: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。

redeemFrom

功能

从指定的 token 持有人中赎回指定量的 token (总供给量会减少)。
入口函数

main

参数

{
    "method": "redeemFrom",
    "params":{
        "tokenHolder": "buQoP2eRymAcUm3uvWgQ8RnjtrSnXBXfAzsV",
        "value": "1000000000000",
        "data": ""
    }
}

返回值

成功: true

失败: 抛出异常
事件
```
tlog('redeemFrom', sender, tokenHolder, value, data);
```
topic: 方法名，这里是 'redeemFrom'

sender: 合约调用账户地址

tokenHolder: Token 持有人地址

value: 赎回的数量

data: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。

redeemTranche

功能

从合约触发者的指定的 tranche 赎回指定量的 token (总供给量会减少)。
入口函数

main

参数

{
    "method": "redeemTranche",
    "params":{
        "tranche": "1",
        "value": "1000000000000",
        "data": ""
    }
}

返回值

成功: true

失败: 抛出异常
事件
```
tlog('redeemTranche', sender, tranche, value, data);
```
topic: 方法名，这里是 'redeemTranche'

sender: 合约调用账户地址

tranche: Tranche 的 id

value: 赎回的数量

data: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。

redeemFromTranche

功能

从指定的 token 持有人中赎回指定量的 token (总供给量会减少)（必须被授予足够的份额）。
入口函数

main

参数

{
    "method": "redeemFromTranche",
    "params":{
        "tranche": "1",
        "tokenHolder": "buQoP2eRymAcUm3uvWgQ8RnjtrSnXBXfAzsV",
        "value": "1000000000000",
        "data": ""
    }
}

返回值

成功: true

失败: 抛出异常
事件
```
tlog('redeemFrom', sender, tranche, tokenHolder, value, data);
```
topic: 方法名，这里是 'redeemFrom'

sender: 合约调用账户地址

tranche: Tranche 的 id

tokenHolder: Token 持有人地址

value: 赎回的数量

data: 允许随传输一起提交任意数据，以便进行解释或记录。这可以是授权传输的签名数据（例如，动态白名单），但是足够灵活以适应其他用例。

canTransfer

功能

能否传输成功。
入口函数

query

参数

{
    "method": "canTransfer",
    "params":{
        "from": "buQnTmK9iBFHyG2oLce7vcejPQ1g5xLVycsj",
        "to": "buQoP2eRymAcUm3uvWgQ8RnjtrSnXBXfAzsV",
        "value": "100",
        "data": ""
    }
}

返回值

成功: true

失败: 抛出错误信息

canTransferTranche

功能

指定 tranche 内的 token 能否被传输成功。
入口函数

query

参数

{
    "method": "canTransferByTranche",
    "params":{
        "tranche": "",
        "from": "buQnTmK9iBFHyG2oLce7vcejPQ1g5xLVycsj",
        "to": "buQoP2eRymAcUm3uvWgQ8RnjtrSnXBXfAzsV",
        “value”: "100",
        "data": ""
    }
}

返回值

成功: true

失败: 抛出错误信息

canTransferToTranche

功能

指定 tranche 内的 token 转移给目标指定 tranche 内能否被传输成功。
入口函数

query

参数

{
    "method": "canTransferByTranche",
    "params":{
        "from": "buQnTmK9iBFHyG2oLce7vcejPQ1g5xLVycsj",
        "fromTranche": "1",
        "to": "buQoP2eRymAcUm3uvWgQ8RnjtrSnXBXfAzsV",
        "toTranche": "2",
        “value”: "100",
        "data": ""
    }
}

返回值

成功: true

失败: 抛出错误信息

transfer

功能

将合约触发者的 token 转移给目标账户。
入口函数

main

参数

{
    "method": "transfer",
    "params":{
        "to": "buQoP2eRymAcUm3uvWgQ8RnjtrSnXBXfAzsV",
        "value": "100"
    }
}

返回值

成功：true

失败：抛出异常
事件
```
tlog('transfer', sender, to, value);
```
topic: 方法名，这里是'transfer'

sender: 合约调用账户地址

to: 目标账户地址

value: 转移数量(字符串类型)

transferFrom

功能

将指定 token 持有人的 token 转移给目标账户 (合约触发者必须被授予足够的份额)。
入口函数

main

参数

{
    "method": "transferFrom",
    "params":{
        "from": "buQnTmK9iBFHyG2oLce7vcejPQ1g5xLVycsj",
        "to": "buQoP2eRymAcUm3uvWgQ8RnjtrSnXBXfAzsV",
        "value": "100"
    }
}

返回值

成功：true

失败：抛出异常
事件
```
tlog('transferFrom', sender, from, to, value);
```
topic: 方法名，这里是'transferFrom'

sender: 合约调用账户地址

from: 源账户地址

to: 目标账户地址

value: 转移数量（字符串类型）

approve

功能

允许指定账户代表Token持有者操作 token。
入口函数

main

参数

{
    "method": "approve",
    "params":{
        "spender": "buQnTmK9iBFHyG2oLce7vcejPQ1g5xLVycsj",
        "value": "100"
    }
}

返回值

成功：true

失败：抛出异常
事件
```
tlog('approve', sender, spender, value);
```
topic: 方法名，这里是'approve'

sender: 合约调用账户地址

spender: 被授权账户地址

value: 被授权可转移数量（字符串类型）

approveTranche

功能

允许指定账户代表 token持有者操作 token。
入口函数

main

参数

{
    "method": "approveTranche",
    "params":{
        "tranche": "1",
        "spender": "buQnTmK9iBFHyG2oLce7vcejPQ1g5xLVycsj",
        "value": "100"
    }
}

返回值

成功：true

失败：抛出异常
事件
```
tlog('approveTranche', sender, tranche, spender, value);
```
topic: 方法名，这里是 'approveTranche'

sender: 合约调用账户地址

tranche: Tranche 的 id

spender: 被授权账户地址

value: 被授权可转移数量（字符串类型）

allowance

功能

查询允许指定账户代表 token持有者操作 token数量。
入口函数

query

参数

{
    "method": "allowance",
    "params":{
        "owner": "buQoP2eRymAcUm3uvWgQ8RnjtrSnXBXfAzsV",
        "spender": "buQnTmK9iBFHyG2oLce7vcejPQ1g5xLVycsj"
    }
}

返回值

{
    "result": {
        "type": "string",
        "value": {
            "allowance": "10000000"
        }
    }
}

allowanceForTranche

功能

查询允许指定账户代表 token 持有者操作 token 数量。
入口函数

query

参数

{
    "method": "allowanceForTranche",
    "params":{
        "tranche": "1",
        "owner": "buQoP2eRymAcUm3uvWgQ8RnjtrSnXBXfAzsV",
        "spender": "buQnTmK9iBFHyG2oLce7vcejPQ1g5xLVycsj"
    }
}

返回值

{
    "result": {
        "type": "string",
        "value": {
            "allowance": "100000"
        }
    }
}

合约入口

init

创建合约时候，触发合约 init 入口函数，负责合约创建时的初始化。
函数
```
function init(input_str){
}
```

参数Json结构

{
    "params":{
        "name": "123",
        "symbol": "STP",
        "description": "STP",
        "decimals": 8,
        "nowSupply": "10000000",
        "scheduledTotalSupply": "10000000",
        "icon": "",
        "controllers": ["buQnTmK9iBFHyG2oLce7vcejPQ1g5xLVycsj"]
    }
}
- name: Token 名称，长度范围[1,64]
- code: Token 符号，长度范围[1,64]
- description: Token 描述，长度范围[1,64k]
- decimals: Token 符号，即能支持的小数点位置，大小范围[0,8]
- nowSupply: Token 当前发行量，大小范围[0,2^63-1]，其值等于10^decimals*发行量。假如当前要发行一笔数量是 10000, 精度为8的 token，nowSupply = 10 ^ 8 * 10000, 结果是 1000000000000。
- scheduledTotalSuppl: Token 计划发行总量，大小范围[0,2^63-1]，0 表示不限量发行，大于 0 表示限量发行，其值等于10^decimals*计划发行量。假如计划要发行总量是 10000, 精度为 8 的 token，scheduledTotalSuppl = 10 ^ 8 * 10000, 结果是 1000000000000。
- icon: base64位编码，图标文件大小是32k以内,推荐200*200像素。
- controllers: Token 的控制者列表，即监管者列表

返回值：

成功：无

失败：抛出异常

main

负责数据写入，其中包含了 setDocument、createTranche、transferWithData、transferFromWithData、transferFromToTranche、transferTranche、transferToTranche、transfersToTranche、controllerTransfer、controllerRedeem、authorizeOperator、revokeOperator、authorizeOperatorForTranche、revokeOperatorForTranche、operatorTransferTranche、operatorRedeemTranche、issue、issueToTranche、redeem、redeemFrom、redeemTranche、redeemFromTranche、transfer、approve、approveTranche、transferFrom 等接口。

函数体

function main(input_str){
    let input = JSON.parse(input_str);

    if (input.method === 'setDocument'){
      setDocument(input.params.name, input.params.url, input.params.hashType, input.params.documentHash);
    }
    else if(input.method === 'createTranche'){
      createTranche(input.params.tranche);
    }
    else if(input.method === 'changeOwnership'){
      changeOwnership(input.params.owner);
    }
    else if(input.method === 'issue'){
      issue(input.params.tokenHolder, input.params.nowSupply, input.params.data);
    }
    else if(input.method === 'issueToTranche'){
      issueToTranche(input.params.tranche, input.params.tokenHolder, input.params.nowSupply, input.params.data);
    }
    else if (input.method === 'approveTranche'){
      approveTranche(input.params.tranche, input.params.spender, input.params.value, input.params.data);
    }
    else if(input.method === 'approve'){
      approve(input.params.spender, input.params.value);
    }
    else if(input.method === 'transfer'){
      transfer(input.params.to, input.params.value);
    }
    else if(input.method === 'transferFrom'){
      transferFrom(input.params.from, input.params.to, input.params.value);
    }
    else if(input.method === 'transferWithData'){
      transferWithData(input.params.to, input.params.value, input.params.data);
    }
    else if(input.method === 'transferFromWithData'){
      transferFromWithData(input.params.from, input.params.to, input.params.value, input.params.data);
    }
    else if(input.method === 'transferTranche'){
      transferTranche(input.params.tranche, input.params.to, input.params.value, input.params.data);
    }
    else if(input.method === 'transferToTranche'){
      transferToTranche(input.params.fromTranche, input.params.to ,input.params.toTranche, input.params.value, input.params.data);
    }
    else if(input.method === 'transfersToTranche'){
      transfersToTranche(input.params.fromTranche, input.params.toTranche, input.params.tokenHolders);
    }
    else if(input.method === 'transferFromToTranche'){
      transferFromToTranche(input.params.from, input.params.fromTranche, input.params.to ,input.params.toTranche, input.params.value, input.params.data);
    }
    else if (input.method === 'controllerTransfer'){
      controllerTransfer(input.params.from, input.params.fromTranche, input.params.to, input.params.toTranche, input.params.value, input.params.data, input.params.operatorData);
    }
    else if(input.method === 'controllerRedeem'){
      controllerRedeem(input.params.tokenHolder, input.params.tranche, input.params.value, input.params.data, input.params.operatorData);
    }
    else if(input.method === 'authorizeOperator'){
      authorizeOperator(input.params.operator);
    }
    else if(input.method === 'authorizeOperatorForTranche'){
      authorizeOperatorForTranche(input.params.tranche, input.params.operator);
    }
    else if(input.method === 'revokeOperator'){
      revokeOperator(input.params.operator);
    }
    else if(input.method === 'revokeOperatorForTranche'){
      revokeOperatorForTranche(input.params.tranche, input.params.operator);
    }
    else if(input.method === 'operatorTransferTranche'){
      operatorTransferTranche(input.params.tranche, input.params.from, input.params.to, input.params.value, input.params.data, input.params.operatorData);
    }
    else if(input.method === 'redeem'){
      redeem(input.params.value, input.params.data);
    }
    else if(input.method === 'redeemFrom'){
      redeemFrom(input.params.tokenHolder, input.params.value, input.params.data);
    }
    else if(input.method === 'redeemTranche'){
      redeemTranche(input.params.tranche, input.params.value, input.params.data);
    }
    else if(input.method === 'operatorRedeemTranche'){
      operatorRedeemTranche(input.params.tranche, input.params.tokenHolder, input.params.value, input.params.operatorData);
    }
    else{
        throw '<unidentified operation type>';
    }
}

query

负责数据查询，其中包含了 getDocument、isIssuable、tokenInfo、balanceOf、tranchesOf、balanceOfTranche、allowance、allowanceForTranche、isControllable、isOperator、isOperatorForTranche、canTransfer、canTransferTranche、canTransferToTranche 等接口。

函数体

function query(input_str){
    let result = {};
    let input  = JSON.parse(input_str);

    if(input.method === 'getDocument'){
      result.document = getDocument(input.params.name);
    }
    else if(input.method === 'isIssuable'){
      result.isIssuable = isIssuable();
    }
    else if(input.method === 'tokenInfo'){
      globalAttribute = JSON.parse(storageLoad(globalAttributeKey));
      result.tokenInfo = globalAttribute;
    }
    else if(input.method === 'balanceOf'){
      result.balance = balanceOf(input.params.address);
    }
    else if(input.method === 'tranchesOf'){
      result.tranches = tranchesOf(input.params.address);
    }
    else if(input.method === 'balanceOfTranche'){
      result.balance = balanceOfTranche(input.params.tranche, input.params.address);
    }
    else if(input.method === 'allowance'){
      result.allowance = allowance(input.params.owner, input.params.spender);
    }
    else if (input.method === 'allowanceForTranche'){
      result.allowance = allowanceForTranche(input.params.tranche, input.params.owner, input.params.spender);
    }
    else if(input.method === 'isControllable'){
      result.isControllable = isControllable();
    }
    else if(input.method === 'isOperator'){
      result.isOperator = isOperator(input.params.operator, input.params.tokenHolder);
    }
    else if(input.method === 'isOperatorForTranche'){
      result.isOperator = isOperatorForTranche(input.params.tranche, input.params.operator, input.params.tokenHolder);
    }
    else if(input.method === 'canTransfer'){
      result.canTransfer = canTransfer(input.params.from, input.params.to, input.params.value, input.params.data);
    }
    else if(input.method === 'canTransferTranche'){
      result.canTransfer = canTransferTranche(input.params.from, input.params.to, input.params.tranche, input.params.value, input.params.data);
    }
    else if (input.method === 'canTransferToTranche'){
      result.canTransfer = canTransferToTranche(input.params.from, input.params.fromTranche, input.params.to, input.params.toTranche, input.params.value, input.params.data);
    }
    else{
        throw '<Query interface passes an invalid operation type>';
    }
    return JSON.stringify(result);
}

标签：10,tranche,STO,value,Token,params,input,BEPs,method
来源： https://blog.csdn.net/shangsongwww/article/details/89684109

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9