9月11日，开发者StephaneGosselin在GitHub提交了一份新提议，公布了一项新的证券型Token–“ERC1400”。新Token提案主打监管功能，目的是方便用户以合法合规方式在以太坊网络发行证券。
6 z( x$ p2 N- V' N7 r! M/ ?9 P: C0 T6 C6 W9 [* q. B# h8 m2 k
    目前，ERC1400还处于起草阶段，未来是否会获得社区通过并投入使用还尚未可知。- s( M4 w0 r; O: [
% _% c& J) v+ K- N
    临界(Hashgard)团队对ERC1400的提案进行了翻译，为所有的开发和技术人员，提供更多支持和助力！+ s  s0 {$ ]4 N
+ g& V; O2 Q5 t% R9 m3 c4 K3 r7 e
    -01-. B1 k) E$ j: e1 m3 V
5 p% q# m- W: Z' O7 x7 _
    关于ERC1400
2 j6 r/ [9 p" Q- S) P
( x- R; M1 D; O    "ERC1400"是新提案的证券型代币的标准，新标准主要是把Token的互换性（fungible）结合证券相关的业务场景，设计了一套通用接口。: A% f! u( a1 I8 g, K' A
' d& ?7 h- ?: N4 K
    标准制定了Token持有人的余额分离成多个分片(tranche)的能力。tranche是一种以债务为基础的投资结构。这些证券将具有不同期限的，投资风险或高或低的tranche组合成一个整体，以达到降低投资者的风险，提供长期投资的目的。例如，你可能有一笔贷款转付证券，其中包括5到30年期的高风险和低风险的转付证券，基于ERC1400标准的Token将支持这种投资方式。$ E( \5 D7 N- [6 I( v! b: S4 H; H

0 o0 R  ^8 j8 ~, W* G! E4 ^    我们先了解ERC777标准，ERC777是ERC20的加强版，旨在加强用户的控制权限，具体有：% l/ P& K' g: @* |2 ]
7 n% P/ l3 [# ]/ o; C8 k
    随交易发送可以附带描述数据，以供某些业务场景使用
1 E  K! j+ Z% w! D3 e2 E0 p
" ?3 r& D, Y- O% u, J4 I    设置一些转账限制，如黑名单
' ]  d9 V' h' d! b5 C% j# Z( E
8 w, L6 q! ^* s! t- b# c% C4 f+ N    支持一些高级交易6 y& F8 n; N7 H  B

% G' _. R& {1 R8 t1 N+ f0 K' s* R$ ]    无论是ERC20还是ERC777，每个单位的Token都是相同的，并无附加属性，属于fungibletoken（同质化代币/可互换Token）。ERC721标准的Token，每个Token均有不同的ID，不同ID可以有不同的解释，属于no-fungibletoken（非同质化Token，不可互换Token）
. q. n- s1 j( X# U: X# ~
+ K& I; l* ~7 F8 w' H! W    ERC1410标准的Token属于Partially-FungibleToken(部分可互换Token)，将ERC20/ERC777中不存在解释属性的余额，附加额外的信息，从而划分成不同的部分，就可以做一些操作上的限制（例如：某些操作只限定于指定tranche的Token，某些操作优先消耗指定tranche的Token）
- v$ H  O" e5 K) e3 e8 U# N& j* t# |3 R. Y
    ERC1400则是继承ERC1410标准，增加了证券相关业务会使用到的函数：证券增发，相关法律文件存储等。
. t: }, u* ?; n8 d- F  @5 @7 Z( I' b" S& T7 j/ G1 c* W2 L4 e
    先前一些证券型Token的合约大多是在ERC20标准的基础上，通过维护一个或多个以太坊地址集合，对这部分地址做出了划分：是否通过kyc，是否处于锁定期等，来进行转账上的限制。这些都是在地址层面做出不同的解释。而ERC1400对Token本身做了不同解释，以适用于更复杂的证券相关业务场景。( \4 n+ C0 c+ R! m5 z

% e( G( X1 X9 R& D7 L1 f    关于ERC20，以及其它ERC成员的关系，可见下图：- k. S' z  A; v; [- A7 \
5 I" R6 X0 j; X& C: D2 N+ o: t$ a
    1.webp(1)7 A; d5 _8 H% j( ^9 u

: a( S) w1 {2 ]2 J    -02-
, S5 O9 L) a9 @! J: C8 p7 W- h$ @$ Z! S) T% E% E% c2 s  ~, X" Z8 I
    ERC1400提案翻译
; z# N) x/ v  s. E" r: f) A/ d' I) n# @3 A5 O6 g
    SecurityTokenStandard# v6 ]% a! C2 b

5 L: K6 H* j6 M0 O7 h    eip:ERC1400
1 O+ k1 t( |% p8 n/ C& j2 w. c
    标题:StandardforSecurityTokens
8 f) Z4 H5 l/ R- R
) n# Q+ d' r0 j, P& J. t0 `    作者:AdamDossa(@adamdossa),PabloRuiz(@pabloruiz55),FabianVogelsteller(@frozeman),StephaneGosselin(@thegostep)
; g% j: [" l! N2 l$ h$ f7 p/ M% d( k+ d6 g) Z/ w  b
    译者:Jason（来自临界Hashgard团队）0 @  \# f+ F! y0 Q: v5 m- d
  v0 }8 K5 `0 \( V5 p4 ]
    状态:Draft
- W7 }: O: x% L6 v* X6 X7 m- `6 j% a+ g, b. O
    类型:StandardsTrack
, }! E& V9 ~' V7 L" R9 s& `% l" t6 {( i' _; q6 a/ P- ~
    范畴:ERC" b, j6 s9 H- ]

/ d& W% Z8 w4 f( t  o8 {2 I$ k    创建于:2018-09-09
- k1 s' i: y; z# o( h
) ?2 O! U4 @: ]; A7 n% `/ l% F    需要:ERC-777,ERC-1066
- m7 q' d+ U0 h& w# ~$ |" ^; L% V; n3 x( V  z' F9 `+ L: W
    Motivation, n# L. J3 A4 n) K

0 ^5 B' k* q+ W# Z% g    通过指定一套标准的接口，加速发行和管理以太坊上的证券，通过该接口所有相关方可以查询和操作证券型代币。9 ]/ z% [) u* H. i) K; O5 E$ D8 [
& e6 j9 J; S  z# X5 ~( B
    证券型代币与其他代币用例存在重大差异，链上与链下参与者的交互更加复杂，有着相当严格的监管审查。
0 J2 E8 r3 C  B& f' o/ M  e( D! m$ N7 D8 J1 n: B) g! y
    证券型代币应该能够对标任何资产类别，在任何司法管辖区内发型和管理，并遵守相关的监管限制。
+ e- e- F0 r# ^$ D7 l1 ]* I8 U, d0 l+ z% ?( F" R8 }$ f, h
    Requirements' X4 A% k: n8 j# @# Z! Q  H0 j

' q. g& }2 i7 f% F# H    将证券的发行，交易和生命周期事件迁移到公共账本上需要采用标准的方式对证券，其所有权及其在链上的属性进行建模。" L1 e8 ?0 V3 ]% r7 V& O* z

, h9 `/ Y7 n1 {: S8 r; {    经证券型代币生态中各方讨论后，编写了如下的要求：
4 N, [' K2 t% s8 A! X) p4 D! O4 `$ F8 l/ f( M) q
    必须有一个标准的接口来查询一笔转账交易是否成功，失败的话则返回原因。3 ]8 d' ~7 p2 Q2 r( Y& \

6 L) l1 r8 K3 p2 i' q3 L: k    必须能够强制转账以应对法律诉讼或资金回收。4 x9 v) L. U% |

1 R! U9 I9 ?; M5 @  }) A: G& H% f    必须发布用于发行和赎回的标准事件。
7 v, J4 L. R6 M% c
! X' H/ Y& r+ |. S    必须能将一些数据附加到代币持有者余额的子集上，例如特殊股东权利或是转账限制的数据。! ^; W* M: `1 T1 Z! G  q

' a% R. B9 e& s' `0 K6 o    必须能根据离线数据，链上数据和转账的参数在转账时修改元数据。0 p  D" v0 i: L; T; Z
/ [* k2 z& j9 o
    可能需要将签名数据传递到转账交易中，以便于在链上验证。
8 r% u7 d0 j2 b0 G) m1 M' a& g6 o  {: z$ q; m" a
    不应该限制可以代表司法管辖区内的资产类别范围。
& b8 l% @4 x: t2 Y  p9 w3 V$ h5 k  M
$ Q1 V$ Y  r5 L0 ~0 M    应该兼容ERC20和ERC777标准。
6 P. V9 d  W- O3 K4 v
! _9 O; E5 G* N, x& C    Structure
- o9 D5 d3 |, G( a3 Y
8 `) r5 B1 Y. }9 ^    ERC-1400:SecurityTokenStandardERC-w:Semi-FungibleTokenERC-w-1:TranchemetadataschemaERC-x:PermissionedTokenTransfers(canSend()andstatuscodes)ERC-y:TokenMetadata(set/getDocument)ERC-z:OptionalSecurityTokenfeaturesForcedtransfersPermanentendtoIssuanceTradingHaltsBatchedtransfers
+ ?) Y+ }. d$ U3 @! |" T
4 R' q: R; u, a/ _& a4 p: m4 ?& j    Semi-FungibleToken- P! W9 K% S: E
6 D6 k8 d  {& K
    –#1410Partially-FungibleToken(部分可互换代币)
; Z& L, S4 d* R' H9 y1 i4 U4 ^) L3 ?' q" W
    –PermissionedTokenTransfers! q) [/ u" J2 j( u  E/ \# m
; p6 t* `) m* D9 O2 P
    –#1400SecurityTokenStandard(证券型代币标准)
& z, a5 d2 n, G) y! `# q$ X, @: S' [' i6 c  x/ k
    –#1404SimpleRestrictedTokenStandard(简单的受限代币标准)4 ~9 D" ?! h9 P* B4 y' p' }

/ {$ q' c. y9 v; a    Abstract
8 v+ j" }+ r8 R; x8 C. ^  f9 ~3 C( Y* n: s
    有许多类型的证券虽然代表相同的标的资产，但需要有与之相关的差异化数据。  O+ }# h9 K- N1 B6 a4 v5 C

1 Z. l2 I+ v! w* I" h. A" p# |    这些额外的元数据隐含地使这些证券不可置换，但实际上这些数据通常应用于证券的一个子集而不是单个证券。将令牌持有者的余额划分为各个部分的能力，每个部分具有单独的元数据，在Partially-FungibleToken部分中进行了说明。
( }( }% i- ~5 R$ `3 T4 b3 b0 w% _( O. ]6 w( Z
    例如，代币持有人的余额可以分为两部分：在首次发行期间发行的代币和通过二级市场交易得到的代币。
% z- w. {5 P; m
+ ~( l# I' j  n. [    证券代币合同可以引用该元数据去应用额外的逻辑来决定转账是否有效，并确定一旦转账到接收方账户中，这些代币所关联的原数据。
9 V- K9 F0 j- D5 r& l* ]  O4 ~) @1 Z# y: }7 _  a0 G0 S
    这些条件可能与正在转账的证券代币关联的元数据有关（即它们是否受制于锁定期），证券发送方和接收方的身份（即他们是否通过了KYC流程，是否是经认可的，或是发行方的附属公司）或者是与具体转账无关的原因，而是设定在代币的级别上（即代币合同强制执行投资人数量的上限，或任何单一投资人持有的百分比上限）。
! ^+ ]' G4 J% Y: P) P$ i+ ^" h+ O1 F! |
    对于ERC20/ERC777代币而言，balanceOf和allowance方法提供了一个在执行转账之前检查转账是否可能成功的方法，转账在链上或是链下都可以执行。, L4 ^& s, ]2 U, I- {

9 Y; x" P, w. N( }    对于标的证券的代币而言，这个标准引入了一个函数canSend，当失败的原因更加复杂的时候，它提供了一种更通用的方法来实现这一目的。还引入了一个用于整个转账行为的函数（即包括同转账一起发送的任意数据和证券的接收方）
; [1 s- r2 E& F' g6 R+ m- W: q) i. m4 n0 k6 D) Q& E, `; c$ Y
    为了提供同true或false相比更加丰富的信息，会返回一个字节返回码。这使得我们能够说明转账失败的原因，或者至少是失败原因的类别。查询文档的能力和对转账成功的预期会包含在SecurityToken部分中说明。
7 j% D  h6 F: X% a/ c2 m4 f
' Q& _( V, P9 b; d% z    #1410-Partially-FungibleToken
" m# w: x+ K. U8 e, C. a
9 Q$ S* P, d) D    一个Partially-FungibleToken允许将元数据关联到代币持有者余额当中的一部分上面。这些部分的余额称为tranches（tranche，实际上是一个法语单词意为“切片”或“部分”。在投资界，用来描述可以被分割成并卖给投资者的小额证券。），并由bytes32_tranche键来建立索引，该键可以同链上或链下的元数据相关联。2 _) y  ^/ p( @( i8 b$ p. P7 k; I
' B0 Z# Z+ O+ `9 {) j3 s( F) Q
    **
( f! d% i' J+ R+ P1 Z9 z. [$ F6 N' b2 D7 Y) C
    SendingTokens**
- X, _% {8 U3 I  k8 m% f  n$ T0 K( o9 ~( s/ `* c; r* s
    代币转账始终具有关联的源tranche和目标tranche，以及通常的转账数量和发送方/接收方的地址。
+ W# ?: X; ^: A* N& k; @3 l5 g% F' r9 y; l+ \
    getDefaultTranches. m# t% H2 U4 N; G

/ C; J7 g" q4 N4 n- v9 M    为了提供对ERC777的兼容性，实现需要决定在执行ERC777发送函数时要使用哪一个tranche。* K' K7 C0 b  B3 D- P5 o
4 r/ C6 O" F, q1 ?- v2 m
    这个函数返回在此情况下使用的tranches。例如，一个证券型代币可以返回byte32(“unrestricted”)tranche,或者使用一小组可能的tranches的简单实现，可以返回与代币持有者相关联的所有tranches。  ^0 |5 d+ D' z3 y, F
0 H7 K9 K; a  }9 y+ z
    返回值可以为空，这意味着没有默认的tranche(因此ERC777的发送函数将抛出错误)，或者返回多个tranches，在这种情况下，ERC777的发送函数应该按照顺序循环遍历这些tranches，直到指定数量的代币已经成功转账。( {( e; N7 U0 _* ?

2 |& l6 g# ^4 G$ l* ^    functiongetDefaultTranches(address_tokenHolder)externalviewreturns(bytes32[]);" Y7 z4 W" p: I' {( z4 h4 ^) \

- n% M6 c2 D$ z    setDefaultTranches
1 p5 S. {, ^4 _& U
4 ^3 i/ T- l; b    允许为指定的地址设置默认的tranches，将会在ERC777的发送函数执行时使用到这些设置。0 ]# p* V; c5 W+ Z+ a! g2 m% ^# J

! T6 F. s# @1 L+ N) q. i& g- [* A    这个函数可以供所有代币持有人自行调用，或仅限于那些实现了某些必要行为的持有人。
9 ]: r& Z2 ]- ~8 r
. F7 i  z3 _/ C/ }( V    functionsetDefaultTranche(bytes32[]_tranches)external;
9 _7 G9 j% f. g! Y/ Z/ a7 H0 e9 X7 u1 `& X2 s
    balanceOfByTranche" b4 H/ }6 F: M  C% T3 _9 B

9 ^2 r/ R" N, T  A" J; d    除了有查询所有tranches下总的代币余额的balanceOf，也要有查询某个特定tranche下代币余额的函数。9 U! L5 z7 }% \5 a* ?# z( j6 `. c

* Z6 C9 z  W3 f" V+ P$ p( ?6 c" K    functionbalanceOfByTranche(bytes32_tranche,address_tokenHolder)externalviewreturns(uint256);3 V; O! p' s9 j1 Y* @$ M; ]
/ x/ h2 N0 C# f- W
    sendByTranche
1 n2 ?, u9 r& g: j' c: q7 j( J/ S" n  [9 d- B
    通过拓展ERC777标准并提供一个默认的tranche(通过getDefaultTranches函数获取)，就可以发送代币了（从默认的tranches）。要从一个特定的tranche来发送代币的话，可以使用sendByTranche函数。
0 T" l+ N. ^1 J$ E) L  }1 Y5 K5 \* B/ Q- U. A
    例如，一个有权限的代币可以使用tranche元数据来强制执行如下的转账限制：, @8 v1 h+ w& J. C; T
# h% w# ?3 z0 E* S7 C# o$ t
    _tranche值6 \% [- c0 i1 [' d7 i, L& o

( C$ f1 v( v. V2 G2 B    与_tranche值相关联的任何额外数据（例如，可能与_tranche关联的锁定时间戳）
3 u& w$ G1 h# ~+ M) i- y; K8 `: @6 e
    与代币的发送方或接收方相关联的任何细节（例如，他们的身份信息已经创建）
0 Z1 z- j+ D9 x) M) z( F- I7 m- [' l, Z$ N* {3 j4 Z! q
    转账的代币数量（比如，它是否遵守任意按天或者基于其他时间周期的转账数量限制）( x" K' y6 y% G: F

1 K; S- g9 f! E8 ?* N) H7 y    _data参数允许调用者提供与转账相关的任何附加的授权或详细信息（例如，来自一个被允许对转账行为进行授权的授权实体的签名数据）, X& u5 w1 y* N% y

3 d  l# E% k5 c$ E    其它的用例包括通过把先前的持有者与目标tranches关联起来，跟踪代币的出处。5 q: |% O( r, X% _
* x# Q# m+ P) ?, U) e
    如果转账代币因某种原因失败，这个函数必须抛出错误。+ j' A  F2 s. ]' n% I6 B2 A4 k

) C7 B1 u9 ~9 Y2 [    当从特定的tranche上转账代币时，了解这些代币的链上的（即不仅是通过一个响应的事件）目标tranche是有用的。目标tranche将会由这个函数的实施来决定，并依据用例而有所不同。2 B: ^2 y; {5 f: v4 u. `

0 I$ q& N- E& L( V0 h8 r0 K    这个函数在转账成功时必须触发一个SentByTranche事件。" H- B6 j7 U3 Q) Y% t$ d) q5 I7 B, R

9 c5 h) R' ~, p, d    functionsendByTranche(bytes32_tranche,address_to,uint256_amount,bytes_data)externalreturns(bytes32);functionsendByTranches(bytes32[]_tranches,address[]_tos,uint256[]_amounts,bytes_data)externalreturns(bytes32);
1 p  c; r7 _  T! O+ T* I
( ]) s* H$ H' }1 v    redeemByTranche
$ l0 o4 N& P5 V3 O/ G" r5 v2 e* @; C3 U. u. Z# [* m
    允许代币持有者赎回（销毁）代币。
" Z( T5 \$ S- I6 g
, s6 I/ f- Z+ V  Y0 j    必须从代币总量和代币持有人账户里扣除已销毁或已赎回的代币。销毁代币应该像发送代币一样，受到相同条件的限制。每次此函数被调用时，必须触发RedeemedByTranche事件。
7 ?' ~6 h: F& ~& ~/ Z1 s4 i
, T2 Y2 }- ^# W# j$ [    functionredeemByTranche(bytes32_tranche,uint256_amount,bytes_data)external;
& @1 a: n1 B5 d) [. {
9 r9 {2 _2 f1 @" s. }  U! s    tranchesOf
# {5 Q# S1 c# Q" E# z) Q
3 g, T0 K3 S) T    代币持有者可以把他们的余额拆分成多个部分(tranches)——此函数将返回与特定代币持有者地址关联的所有tranches。/ F7 d/ e1 |5 f2 ]% k7 U

5 ?5 _9 Q& X/ q: B3 G0 H  P. x    functiontranchesOf(address_tokenHolder)externalviewreturns(bytes32[]);
" x) Q" W9 }' V* m# z7 h
" P: d2 z+ P. @    Operators
' M5 `3 }, y2 A2 G7 Z
$ ^7 t" a8 K8 S    操作者可以获得以下授权：
. W% [% f: h; z! ^! S' G! d: [( {8 K6 c
    所有的代币持有人和tranches(defaultOperators继承自ERC777标准)( Z% i/ o$ z4 ]& L4 R7 \2 U/ [

; ]: R/ H+ ~% h. S$ e+ J/ B6 |3 ~    一个特定tranche的所有代币持有人（defaultOperatorsByTranche）
1 e5 x2 T8 ^" Y% ]( D  s$ P4 U. z! T( f! C( d
    一个特定代币持有人(isOperatorFor继承自ERC777标准)的所有tranches(当前的和以后的)/ p6 ^. w/ t. h* R1 p2 v5 P  V
) q% r! T3 m& C9 s
    一个特定代币持有人的特定的一个tranche(isOperatorForTranche)
9 i$ U4 y$ C5 L2 x" b. v0 t" X! h' n8 Q1 a+ c  W
    defaultOperatorsByTranche; w9 H- w- N: G$ P) K

1 l$ s; t5 E: E+ k# z& A    此函数返回默认的由所有代币持有人和一个特定tranche授权的操作者集合。
7 B' I, s! s  ]& g& Q2 s  |8 `3 j7 c& K
    functiondefaultOperatorsByTranche(bytes32_tranche)externalviewreturns(address[]);
/ `  l: ?: m9 v+ _; B% {2 E( N( z$ _$ K+ _4 m2 g
    authorizeOperatorByTranche
! [( p5 ~, G( p: \/ ~- k" l) Q/ C, W, j* x8 m- n
    允许一个代币持有人去为他的某个指定tranche的代币设置一个操作人。5 a) \# X/ J7 j% z& G3 u8 |

. n9 O9 N: X: E- J8 @    每次调用此函数时，必须触发AuthorizedOperatorByTranche事件* N7 T8 j1 [; c5 M% R& `

5 {, W$ F  N8 Z/ s" U: w    functionauthorizeOperatorByTranche(bytes32_tranche,address_operator)external;: G  `4 ]* B- W

, F8 S/ j2 V# z) ?) z. h" X    revokeOperatorByTranche
4 w# a" j1 }3 w; S' |3 z
1 N& j2 E5 Q; z" J% o2 d    允许一个代币持有人撤销其某个特定tranche的代币的操作人。+ `" F2 f, n/ L" L

# E; B6 O1 ?6 }6 [9 j    注意——操作人可能会通过defaultOperatorsByTranche或defaultOperators保留对该代币持有人和tranche的授权。
1 D& V( h/ L. v& Y* m9 S6 |1 q$ A. f+ w' H& H* i' |( D
    每次调用此函数时，必须触发RevokedOperatorByTranche事件。: l. |. n4 T* u& \

  r7 s2 D8 l; H. o    functionrevokeOperatorByTranche(bytes32_tranche,address_operator)external;
* {. K% l3 M9 S" a8 E" a/ [" R: [
& y; C/ X3 g& U1 y% |+ Y2 z! r    isOperatorForTranche
4 t6 c2 S! L6 [2 u
* f  C7 u: q" }# [    返回某个特定地址是否是给定代币持有人和tranche的操作人。( v5 M8 J7 h; z

  I: O; i  O: g+ j2 S5 {    如果地址是上述任何类别下的操作人，则应该返回TRUE。
3 `! T+ A: G6 h5 \3 [5 x; ?
; O% m% b' I5 j- m; g2 ]8 h- L    functionisOperatorForTranche(bytes32_tranche,address_operator,address_tokenHolder)externalviewreturns(bool);
; x/ B# J0 }9 D, a! I
5 v6 q9 J4 ~5 B( J, y- B# W" E$ |) m; Q    operatorSendByTranche+ s' R8 d1 U% W

2 g3 Q; j( X! Q9 s    允许操作人代表代币持有人发送证券型代币。
; M2 J' j9 |- E, ~" M) |3 o% J$ k$ s2 C7 e/ A7 ~  b
    此函数应该返回接收方的bytes32_tranche。; k! J5 w! B9 M( [' z% y. d5 }
9 v& O0 a7 p7 `/ O
    如果是在链下生成的话，接收方的bytes32_tranche可以在bytes_data中定义。
; @% Z- y2 n4 a# s1 O
' A% M2 R" c( E& X    如果此函数被一个缺少由isOperatorForTranche定义的合适授权的地址调用的情况下，必须回退。3 H+ d4 F5 e5 R# b

+ A7 b0 _8 P5 I' Z    此函数在成功发送代币后必须触发一个SentByTranche事件。5 n5 @1 c" y) H9 B0 P7 ~

# c) {  R5 O1 U. ~+ R) |! f    functionoperatorSendByTranche(bytes32_tranche,address_from,address_to,uint256_amount,bytes_data,bytes_operatorData)externalreturns(bytes32);functionoperatorSendByTranches(bytes32[]_tranches,address[]_froms,address[]_tos,uint256[]_amounts,bytes_data,bytes_operatorData)externalreturns(bytes32[]);1 |6 C3 B' i$ C# m. r0 `& Y

2 ]0 P- s) Y$ L( U9 B6 ?( z6 d" B    operatorRedeemByTranche
/ Z% H7 G# v; `3 K. Q3 T" i# u' h; P. n3 Q
    允许一个操作人代表代币持有人销毁或赎回代币。
, i0 X: i5 B5 a5 `1 j8 D/ d: S" ?3 A# G( K
    必须从代币供应总量和代币持有人账户中扣除被销毁或赎回的数量。销毁代币应该同发送代币一样，收到相同的条件限制。每次调用此函数时必须触发RedeemedByTranche事件。) ]  [5 b/ w- Q- F% P
2 H/ Y5 F, m/ Q' e" c% g
    functionoperatorRedeemByTranche(bytes32_tranche,address_tokenHolder,uint256_amount,bytes_operatorData)external;1 P9 m; h1 U; u# {2 o

. I" z" z5 y1 r5 M& v9 `2 }    Interface
5 x3 \- q2 Z- ?2 r5 W; a3 k0 g# v$ s: H0 z# ^7 N
    ///@titleERC-PFTFungibleTokenMetadataStandard///@devSeehttps://github.com/SecurityTokenStandard/EIP-Spec' \) Q7 T) {  b3 e
& X$ [# B& Q1 [% u
    interfaceIERCPFTisIERC777{7 [( R0 D. e  F* w1 \
" q, g( x. g; x# ~4 @  }$ L
    functiongetDefaultTranches(address_tokenHolder)externalviewreturns(bytes32[]);functionsetDefaultTranche(bytes32[]_tranches)external;functionbalanceOfByTranche(bytes32_tranche,address_tokenHolder)externalviewreturns(uint256);functionsendByTranche(bytes32_tranche,address_to,uint256_amount,bytes_data)externalreturns(bytes32);functionsendByTranches(bytes32[]_tranches,address[]_tos,uint256[]_amounts,bytes_data)externalreturns(bytes32[]);functionoperatorSendByTranche(bytes32_tranche,address_from,address_to,uint256_amount,bytes_data,bytes_operatorData)externalreturns(bytes32);functionoperatorSendByTranches(bytes32[]_tranches,address[]_froms,address[]_tos,uint256[]_amounts,bytes_data,bytes_operatorData)externalreturns(bytes32[]);functiontranchesOf(address_tokenHolder)externalviewreturns(bytes32[]);functiondefaultOperatorsByTranche(bytes32_tranche)externalviewreturns(address[]);functionauthorizeOperatorByTranche(bytes32_tranche,address_operator)external;functionrevokeOperatorByTranche(bytes32_tranche,address_operator)external;functionisOperatorForTranche(bytes32_tranche,address_operator,address_tokenHolder)externalviewreturns(bool);functionredeemByTranche(bytes32_tranche,uint256_amount,bytes_data)external;functionoperatorRedeemByTranche(bytes32_tranche,address_tokenHolder,uint256_amount,bytes_operatorData)external;
2 ^9 e! j, w. R1 v# B5 S, a$ t% P% E. T# l' f5 U
    eventSentByTranche(bytes32indexedfromTranche,bytes32toTranche,addressindexedoperator,addressindexedfrom,addressindexedto,uint256amount,bytesdata,bytesoperatorData);eventAuthorizedOperatorByTranche(bytes32indexedtranche,addressindexedoperator,addressindexedtokenHolder);eventRevokedOperatorByTranche(bytes32indexedtranche,addressindexedoperator,addressindexedtokenHolder);eventRedeemedByTranche(bytes32indexedtranche,addressindexedoperator,addressindexedfrom,uint256amount,bytesdata,bytesoperatorData);eventIssuedByTranche(bytes32indexedtranche,addressindexedoperator,addressindexedto,uint256amount,bytesdata,bytesoperatorData);}
/ b3 x/ V; I# t, W, [: a! A+ [
4 V! |; @2 s+ b- v    Notes
- x# q9 q; H5 `0 n) _$ B0 N) d! f; ~1 A' O  K( c# s* _9 {
    ERC20/ERC777BackwardsCompatibility(向后兼容ERC20/ERC777标准)
5 T/ Z: l7 n/ j' B+ A
5 i/ \+ F* B0 e" x+ j! O    为了保持向后兼容ERC20/ERC777(以及其它可互换代币标准)，必须去定义在执行一个transfer/send操作时（即未指定tranche时），应该使用哪一个或者哪几个tranche。' J3 F$ h; u7 ~0 L6 j! B7 Z3 M

6 t) c  B" [& }# Z% E% }+ P; q0 `7 V    如果函数实现保证每个代币持有人尽可能的tranches的数量，则迭代代币持有人的所有tranches（通过tranchesOf）是合理的。+ b2 }: f/ k' q7 d0 m

+ q6 ]* n# k5 V% B. X    代币创建者必须为所有的代币持有人指定一个或多个默认的供ERC20/ERC777标准下函数使用的tranche。每个代币持有人或者其所有tranches的代币余额的操作者，可以更改代币持有人的默认tranche。代币持有人去更改他们的默认tranche的能力允许他们更改显示在还未兼容ERC_PFT的ERC20/ERC777钱包中的tranche。
3 W) ?5 c- B7 a' m
1 ^7 `9 X8 K. s* p6 A    以下是对ERC777标准函数的实现描述：  R5 J- E% A; a4 \; j  [
# M# u( E1 i# `5 N8 I7 g! [
    send()必须使用getDefaultTranche()来获取默认的tranche。
0 ~1 \( W" _, ^1 L- n% F& ^0 W
4 O) X1 E' B* H, C+ j) z* q    opratorSend()必须使用getDefaultTranche()获取默认的tranche。. x1 \: e' H/ r" M8 v( `/ w
  |1 u7 a) Y2 j
    REDEEM()必须使用getDefaultTranche()来获取默认的tranche。
  N- z/ b" }7 x0 ~3 K$ d6 F1 p- K! ?* G7 B+ X/ [: X
    opratorRedeem()必须使用getDefaultTranche()获取默认的tranche。
/ G, y+ [' D2 ]! {; Y8 b6 K( d4 G+ M. `7 I" y( o" E. b+ ^: v
    balanceOf()必须计算指定代币持有人的所有tranche的余额总量。3 }% ]. L! u* r  w" S% S2 _( I0 y
# }1 H& x% S6 D" p& `
    totalSupply()必须返回被该合约跟踪的所有代币总量。
6 r6 Z* u% ^  Q" U& l
; t% u6 ^* f" Z, n8 q% `' Q    defaultOperators()必须查询可以操作所有地址和tranches的操作人列表。
1 u2 w$ `. E2 P5 v1 k' i; N# `2 V4 G7 \5 l6 W
    authorizeOperator()必须对msg.sender的所有tranches授权一个操作人。8 |& R: Y% @7 k" @" g" S2 h2 [+ R0 v

3 n* K1 ?1 _5 l$ N2 I% }' ?    revokeOperator()必须撤销先前对msg.sender的所有tranches授权的操作人。7 l9 [& |# c/ |  Q* m
& y9 c( Q4 ]/ X- [6 E! _
    isOperatorFor()必须查询_operator是否是_tokenHolder所有tranches的一个操作人。
# Y) H' t( k! z) s. |1 |
( J+ C+ }0 |- X# U; b    事件Minted()和IssuedByTranche()必须在代币供应总量有任何增长时触发。, E% N6 }2 D3 J5 C# p0 W, ]
% {8 B& N; J: V4 R/ U
    事件Burned()和RedeemedByTranche()必须在代币供应总量有任何减少时触发。9 `, f* L% I. w0 u3 ~3 B
. w& Z2 P7 R( ?) o% ^) u
    事件AuthorizedOperator()必须由authorizeOperator()触发。" {' k+ j, Q0 a2 g
' q  n& E+ D* _9 h: c) l/ F
    事件RevokedOperator()必须由revokeOperator()触发。9 V8 {) \$ m8 r3 t
6 q* O( O2 u  m
    –#1400-SecurityToken
2 `5 k5 n9 Q. n  |" ~2 {
- Q" N) _. M6 J( O( u    Methods9 y* J- q, x0 K0 [! a$ Q

- L" \6 i3 g2 U" o    getDocument/setDocument
. g' t4 f2 V" c+ o9 r0 Z3 N+ b7 B
    这些函数用于管理与代币关联的一个文档库。这些文件可以是法律文件或者是其他参考资料。
) G6 E5 h6 ~+ g4 x+ h5 W1 ~0 r& \8 c" d' ?6 c) ?5 [) B* V
    文档与短名称（表示为一个bytes32）相关联，并且可以选择有一个同其链上相关联的文档内容的哈希值。& H( C- ?; W0 S$ z
5 P2 U2 c2 r/ F0 M
    functiongetDocument(bytes32_name)externalviewreturns(string,bytes32);functionsetDocument(bytes32_name,string_uri,bytes32_documentHash)external;
$ T8 C% G& S0 E- A* D. q' d
/ M: V3 P4 h! A; |" W5 e5 F    canSend7 l, E+ \1 J& i4 V9 R5 J
& U; u3 b6 N3 W6 `8 I# t) F0 y
    证券转让可能由于多种原因失败，例如：# [6 _/ H: E: ~  l: D$ ^8 H8 R% j

# Z/ q, x2 {% i( ^5 i$ y  X- V    代币发送方或接收方的身份信息。5 f& ^+ H! m# @& v' }# Z' R+ ?. K

; a6 M6 X4 o) \- [    对转账的特定代币的限制（即与转让代币相关tranche的限制）2 f/ ?% ]4 O5 {3 U
, c2 X# }* Z# k6 p
    对代币总体状态相关的限制（即投资人总数）( u6 A# c* x/ _& e
" h4 `) d; c& z+ _
    该标准提供了一个链上函数，用于决定转账是否能成功，并返回指示转账失败原因的详细原因。# U$ d. {  r) u  S  I

0 m3 x4 A7 ^$ R6 x% k3 G    这些规则可以由智能合约还有链上数据来定义，或者依赖可以表示对转账进行授权的sendByTranche函数（例如，声明转账有效性的转账代理的签名信息）返回的部分_data。
' f1 b; U7 F- k. {# m, R: U  X/ Z. |+ E+ \0 R
    此函数将会返一个遵循ERC-1066标准的ESC(EthereumStatusCode，以太坊状态码)，还有一个可以用于定义程序指定原因码及额外详细信息（例如，执行发送操作的转账限制无效）的bytes32参数; F' i8 S4 ^" g' b9 s" S

* U: ~5 s6 n- T6 H6 [, h    此函数也会以与sendByTranche类似的方式返回所转账代币的目标tranche; H. W' T$ z& @- J4 [9 G
: d; a6 _9 G1 L
    functioncanSend(address_from,address_to,bytes32_tranche,uint256_amount,bytes_data)externalviewreturns(byte,bytes32,bytes32);( D: r, j% T; ]. I/ m
( p3 v/ o# V3 ~+ _! R
    issuable
4 F, u& A8 m7 Q4 P$ n" B8 q
% S1 A5 \/ X# _: C    一个证券型代币发行人可以指定此代币的发行已结束（即，不能铸造或发行新的代币）
8 K( W8 m1 H  G6 \/ v) P, Q/ \0 r- t. c! @/ u; C  s  Q2 |$ g
    如果代币在issuable()返回的是false，今后只能返回false。
9 Z- c7 U9 \/ E; p; k
! G2 U) @- j) B% {) n: d    functionissuable()externalviewreturns(bool);
: s, _" A3 [: q# C5 m3 \$ I" P" q  d5 c& R0 c! I* d' h7 d
    issueByTranche+ j& S; k2 j/ ]- r2 Y7 Z# j; l, W
7 y! g0 W3 v4 [6 c* Y7 o" L1 W" H' }
    此函数在增长代币供应总量时必须被调用。+ R- p" A) i& N% C1 T9 {9 x3 i

- R: R4 J8 W6 l& w6 [9 `4 b    在调用时，此函数必须触发IssuedByTranche事件。/ ^& U" e! }/ `2 Y

% y( a( B" X4 v0 M    functionissueByTranche(bytes32_tranche,address_tokenHolder,uint256_amount,bytes_data)external;
/ A2 z0 ^2 c" \4 K1 p6 F/ Z2 x  N
    Interface/ {, D. b4 b2 d! V+ [
6 z( p9 f% h8 U8 D
    ///@titleERC-STFungibleTokenMetadataStandard///@devSeehttps://github.com/SecurityTokenStandard/EIP-Spec( C( `- k) S0 }. h8 j

0 q4 F8 G. V0 U, ~! a7 A  L    interfaceIERCSTisIERCPFT{functiongetDocument(bytes32_name)externalviewreturns(string,bytes32);functionsetDocument(bytes32_name,string_uri,bytes32_documentHash)external;functionissuable()externalviewreturns(bool);functioncanSend(address_from,address_to,bytes32_tranche,uint256_amount,bytes_data)externalviewreturns(byte,bytes32,bytes32);functionissueByTranche(bytes32_tranche,address_tokenHolder,uint256_amount,bytes_data)external;}3 V# t9 i1 ~7 G8 `+ e' x, ?, X

; {( B0 w& p' b$ Y    Notes
, T) ~/ J; q( Y4 [" b$ S/ `1 t  b% G& L, u' x& E7 j
    ForcedTransfers0 B$ L2 R7 |( W. D. R2 Y" Q: X, |

# ?9 X; @* p$ y; Z    可能是法规要求发行人或受信任的第三方保留代表投资人转账代币的权利。因此，ERC-ST规范取代ERC-PFT，因为不得允许代币持有人撤销默认的操作人。1 ^' b6 f" b, ~5 O

( C4 K6 p. _; l# F, Z    RestrictedTransfers
2 t4 @1 Z$ a7 I/ q+ C4 a. g
% L& W9 G+ g% ~8 q6 m    相比实用型代币，证券型代币的转账可能因为多种原因而失败，而实用型代币通常仅要求发送方有足够的余额。, S( r2 Z6 q: P6 i, E' ~
% t; X+ I" X+ d6 `" u+ b+ m: n
    这些条件可能与被转账的证券型代币的元数据有关（即它们是否受制于锁定周期），代币发送方和接收方的身份及资格（即他们是否已经通过了KYC，是否是可信任的或是发行方的附属机构），或者出于与特定转账无关的原因，而是出于监管下证券层面的原因（即证券强制执行投资者的最大数量和单一投资者持有百分比的最高上限）。
. D9 m8 ~( ^/ H
! T! e" F% L1 ]0 m4 b% w5 F    对于实用型代币（ERC20/ERC777标准的），balanceOf和allowance函数提供了一种方式用以在执行转账操作前检查转账是否可能成功，可以在链上或链下执行。3 p2 Y/ p  g+ H# W4 Y, d

- ~. x1 B9 K, T7 J6 [. g    该标准引入了一个函数canSend，它提供了一种更通用的方法来查询发送代币能否成功。它接收一组参数，参数可能包括签名数据，并返回关于交易成功或失败的原因字节码。
/ m' p8 R& A  o- U/ n+ \8 V; h8 @8 @+ }
% p/ @" k9 }" i9 B- J  U0 ^0 s9 Q; y    注意——调用canSend的结果可能会根据链上状态（包括区块高度或时间戳）和链下预言机发生改变。因此，在作为不修改任何状态的视图函数被调用之后，它不能保证将来的转账一定会成功。
8 R' @9 e; F/ H% j- z. w& ^8 {/ Y7 o$ u+ e) z
    Identity( K8 |6 D9 q, b" t$ d2 a; M8 q

% S, W2 R* d; Z, N* T- C0 ]    在许多司法管辖区，一方能否接收和发送证券型代币依赖于该方身份的特征。例如，在一方有资格购买或出售特定的证券之前，绝大多数的司法管辖区都要求具有某种程度的KYC/AML流程。另外，一方可能被分类到投资人资格类别（比如，合格的投资人和购买者），并且他们的公民身份也可以告知与其证券相关联的限制。
2 w( B6 W( g7 n. J5 n, A" h6 n$ f$ Z% e) z% p, J
    多种身份标准（比如ERC725，Civic，uPort）可用于捕获某一方的身份数据，以及集中管理的其他方法（例如，维护一个经KYC批准的地址白名单）。这些身份标准的共同之处是以太坊地址（可以是一方的钱包地址或者身份合同），因此canSend函数可以使用证券型代币的发送方和接收方的地址作为确定是否符合资格要求身份的代理。
; T2 {0 x- f! n1 @& v& a; l) @5 o9 u/ S4 w8 Q
    除此之外，该标准并未强制要求任何特定的身份识别方法。  L% G: ?; l! N- z

, G, E* i( `8 s( f+ w+ y    ReasonCodes( n4 z; m. V+ F- N3 c, y

1 I8 h# t( O4 }    为了改善代币持有人的体验，canSend必须依据下面指定的ERC-1066标准应用程序特定状态代码返回成功或失败的原因字节码。具体的实现还可以将任意数据以bytes32的形式返回，以提供原因码以外的额外的信息
# H. n' K+ w) O! E! u4 R' N3 _' a7 {
    Code/ ]! S( E, v7 I
) m3 g, P2 T6 T. u  f
    Reason, C$ ]  L  r$ U: b; M

; o: R* D8 D1 O# f. n    0xA0TransferVerified-Unrestricted2 Y$ Z7 R0 t4 J/ W5 u7 q2 @3 F

; U% B2 M, R8 f: }1 @. u. I9 n& ^    0xA1TransferVerified-On-Chainapprovalforrestrictedtoken5 a2 M1 x6 C* @

2 y& p: `% ^4 [9 N' X8 b    0xA2TransferVerified-Off-Chainapprovalforrestrictedtoken
+ Q; f: e& V9 a" f: c: g4 e1 d! ~$ Q+ O# U$ v6 _* S. [
    0xA3TransferBlocked-Senderlockupperiodnotended
6 F5 [0 @! X( k2 n- E5 H" n' }
' Z8 v5 f: X- W( R2 }    0xA4TransferBlocked-Senderbalanceinsufficient" I% J; }$ V  E3 F

8 T1 a; l/ {5 o6 x: B$ o/ |    0xA5TransferBlocked-Sendernoteligible
) u$ ~8 q6 d& }" Y  N) x7 k3 ?$ j$ I1 y$ B2 `
    0xA6TransferBlocked-Receivernoteligible
8 v; {  |7 Y* Y7 a# \
# D( _; m% d7 F" Z; P- I- b( y    0xA7TransferBlocked-Identityrestriction) I2 R+ u7 U5 ]" ?8 Z) Y! V

1 l  h/ Q7 R  s' @4 ]    0xA8TransferBlocked-Tokenrestriction
  x# \2 M1 @! P. c) j+ s( Z; g# {
: K0 S6 k4 ?2 m! P  `: C    0xA9TransferBlocked-Tokengranularity
7 ?! c8 B" p- T8 |0 p) n
4 Z, _/ |% x+ s, Q6 M' s+ Q, q    On-chainvs.Off-chainTransferRestrictions  \5 @$ n; T0 e+ k; j
6 l% {+ _/ N9 V9 w
    确定一个证券型代币能否被发送的规则是可以自动执行的（例如，对证券投资人的最大数量限制），或者需要一些链下的输入（比如，经纪人对交易的明确批准）。为了方便线下的情况，sendByTranche和canSend函数接收一个额外的_data参数，该参数可以由批准方签名并用于验证传输。6 A( Q& t2 O' i9 O% T. P! d2 x

8 \3 w5 o, e0 W% T: D    此规范超出了本标准的范围，具体的实现也是特定的。