Hi 游客

更多精彩,请登录!

比特池塘 区块链前沿 正文

以太坊ERC20与ERC233的区别

真无牙泛
106 0 0
什么是ERC2230 w* ?) u( z! y$ K* I% S/ b

  _! R  ]$ c0 ?/ t4 ~& f9 b0 ?9 c) x    ERC223是继ERC20后推出的新标准,解决了ERC20中的一些问题
2 J/ ^( n* j! b5 D- F. P
$ B: R* s7 x9 [* u* K    相关说明" j) ]9 Q* V) `$ a. B! R: i
1 r# D; R0 E0 |9 h( Z5 R/ N, A
    ERC223开发的主要目标
) X$ q% Q6 l4 |% J8 d% M
3 {2 i+ q8 F3 c% l+ j; U    1.合约中意外丢失token:有两种不同的方式来转移ERC20token:1)合约地址2)钱包地址,你需要调用transfer发送给钱包地址或者调用approve在token合约然后调用transferFrom在接收的合约来发送到合约。意外地,对合同地址调用transfer函数的调用将导致接收方合同内的token丢失,令牌将永远不会被访问。
% ?6 {1 v0 s( S4 Y8 s; B9 O! L8 B; v! i9 _  V
    2.无法处理进入的令牌交易:ERC20token交易是合约内的transfer函数的调用。当交易发生时,ERC20令牌合同不会通知接收方。此外,没有办法通过合同处理传入的令牌交易,也没有办法拒绝任何不支持的令牌。( b; }+ A' L' W: }

2 x; H# P6 B" W/ E& }6 ?. \" c    3.实际上,钱包地址和合同之间的ERC20令牌交易是两个不同的交易:你应该在合约上调用approve,然后再调用transferFrom在另一份合约上,当你想你的token委托过去。6 N, z  F! N% M" j! \" S
# b, G: Z/ ?+ |( d% ?2 V+ {; U
    4.Ether交易和token交易行为不同:开发ERC223的目标之一是进行与Ether交易相似token牌交易,以避免用户在转移token时出错,并为契约开发人员更容易地与token交易进行交互。$ l! p% B6 v7 a" |  u# R, t

0 V; r1 s. \+ y    ERC223的有利形势5 s/ p. G+ P" g" [

& S1 Q! w/ H9 @: Q9 ~- @    1.提供避免不符合发送令牌的合同内的意外丢失令牌的可能性。
2 O3 c& w& h% O/ s) y# q3 W2 _. Q( S# C# f  i' `& k4 k, X; L
    2.允许用户通过一个函数调用发送到任何地方他们的令牌。收件人是否是合同是没有区别的。没有必要了解令牌合约如何为常规用户发送令牌。
8 n- G! v$ |8 x' y% {+ p& O* T) G* k5 s; k  C
    3.允许合同开发人员处理传入令牌中的交易。
" l+ Z3 }- {, G, x! e6 H& D. a- H9 F# j: G4 N
    4.ERC223转移到合同消耗比ERC20批准少2倍gas和transferFrom在接收机的合同。
3 n' m2 N: B' x2 `& ~3 t1 p4 D& o1 s+ G/ b8 Q
    5.允许将令牌存入单一交易的合约。防止额外blockchain肿胀。
8 E" W: m7 {$ U% n! ^
; g- A8 i* }6 Y: S    6.token交易类似于Ether交易。
( b) x" a3 Z7 v/ ^6 x/ s
. `; m, a7 D% ?/ f    ERC223令牌应通过以令牌合约的方式transfer函数发送,但请注意,如果接收方是合同或电子钱包地址,则不会有差异。如果接收者是钱包,则ERC223令牌传输将与ERC20传输相同。如果接收方是合约,ERC223令牌合约将尝试在接收方合约中调用tokenFallback函数。如果接收方没有tokenFallback函数,合约事务将失败。tokenFallback函数是Ether事务的后备功能模拟,可用于处理传入事务。有一种方法可以将bytes_data附加到类似于连接到Ether事务的_data的令牌事务。它将通过令牌合约,并将通过接收方合同的tokenFallback函数处理。还有一种方法可以在没有数据参数的情况下使用ERC223令牌合约传输函数,或者使用没有传输函数数据的ERC20ABI。在这种情况下_data将为空字节数组。$ m  e: R0 T- L" ]! i
5 f- l" j& j& r/ a
    概述
7 ]$ R8 L) O4 `; Y; S* G+ {6 m7 ~2 A: c
    ERC:223. ?6 d% R* L( T4 ^6 u+ t5 J3 x
( w5 i# y6 _& m
    Title:Tokenstandard
6 L  L' m; |* w! k. c4 o; r2 L" |/ F) I! W% [/ o
    Author:Dexaran,dexaran820@gmail.com# \$ x7 T) S( N/ y. B2 L; H
6 {( H4 M6 O. T/ R; t3 H% a# N. H
    Status:Draft
) d$ M1 I8 _- d/ u7 O% r7 f( N( Z1 x# s& M8 G0 |
    Type:ERC: c! h% K; R! |3 L

6 u; r* s7 ^( y& t    Created:5-03.2017. b& E4 y3 g8 e# I0 l/ z) [, I

# e' v2 V( l  G) O5 P    Resolution:https://github.com/Dexaran/ERC223-token-standard
. @% ?% f% r. e, \
! f/ ^/ B# k  H. L* m; }; ^) l    Recommendedimplementation:https://github.com/Dexaran/ERC223-token-standard/tree/Recommended
8 m: [$ c  q  I& r* g' o$ Y3 K- [$ N9 i
    以下描述标准功能,令牌合同和使用指定令牌的合同可以实施,以防止意外发送令牌到合同,并使令牌交易的行为像ether交易。
" u2 k$ u- _9 ~
6 `. H2 o( H5 D0 X0 ]3 X    动机
+ \8 P  P4 r% ^* w
0 n$ f7 B; E) u. D+ \0 P+ B    ERC223解决了ERC20的一些问题:
) ]0 m5 d6 w) o$ |8 |8 y5 x, V2 ?6 [& @6 s; c2 J7 K  w. |3 z
    1.无法处理接收合同中的进账交易。* t% W/ _/ c# K) a9 g5 l6 h

  [- R3 t) `  z7 o: d# O% j    2.令牌可以发送到合同中没有设计不处理与标记工作,并可能会丢失。目前至少有四十万美元的损失。/ N/ U- `4 S- s" Y. T, b9 ^- a& R
. g& o( ]' R! V6 [1 _. D2 l) p
    3.令牌交易应与Ethereum意识形态一致。当一个用户转账的时候,必须自己执行transfer.用户存入合同或发送到外部拥有的账户无关紧要。
  P2 A0 V2 h: j+ W" [, x4 X, j1 o0 N; R6 _0 R: K* g. j$ W
    这些将允许合同处理传入令牌交易并防止意外发送的令牌被合同接受。
" [( _# C5 m- |3 b
) w% _( o: s; X* L    例如,分散式交换将不再需要强制用户通过令牌合约来呼叫批准,然后通过从允许的令牌获取正在调用transfer的呼叫存款。令牌交易将在交易所合约内自动处理。5 `2 u" W3 E' _* W. w8 _9 \

9 }2 o$ l2 \5 B( }+ x  F! v    这里最重要的是在执行合同交易时调用tokenFallback。  @* f" E) J3 p- E9 t8 _6 R

4 L$ {/ q) E. s; l1 O+ N    规格
: B; q/ }" Q9 T% `4 }! N. E; u. \3 W0 \/ b3 v8 R* p& P
    Token2 n9 T3 ~9 I2 X, \- ~

% Z: _/ I9 ~# l1 D) b" z5 d4 C# `    使用token的合约9 R$ M6 }% v) r9 ^
* W5 [' _4 d" ?
    方法
# W+ |, ]  E0 w  j% Y7 j- d0 a3 `  `$ ~) l% p
    注意:一个重要的一点是,如果合同开发人员希望他们的合同使用指定的令牌,那么合同开发人员必须实现tokenFallback。2 `( y7 I4 }- z& _
9 e7 q  T1 D0 @3 D6 m
    如果接收方未实现tokenFallback函数,则认为合同不是设计为使用令牌,那么事务必须失败,并且不会传输令牌。在尝试将Ether发送到没有实现function())的合同时,与Ether事务的类比是失败的。
$ e5 J8 @0 b9 }( L. T5 ^. k# z! F
    totalSupply
3 p4 k8 g6 B3 ~% ^
6 v7 O# g  n* p$ Z! W& B- W9 P5 q    functiontotalSupply()constantreturns(uint256totalSupply)
7 c9 B$ X. m' C8 ?# I6 T0 s9 |7 T$ v2 B# |
    获取总量
3 b' z3 D* x1 z5 b! c4 C5 P: X$ U. i" }% Z- V6 h. C5 t
    namename# q# A9 q9 H' o, @( L* b4 v

! X  {/ x9 ]! Z8 s* \) P2 x$ j    functionname()constantreturns(string_name)/ ]/ m; k- a1 Y% X6 W
& G# M( H0 v! S  C  |
    得到token的名字+ q: x; {1 a2 ~
+ O2 E" b7 k0 J, {9 }8 P0 I$ a
    symbol
! g8 ?* L$ ~! z( l5 N$ M: [# ^( G( C8 p: q
    functionsymbol()constantreturns(bytes32_symbol)
. u+ {! T, ~* v0 ]5 o' w- q. C. ]) x/ E4 }7 b$ I2 {
    得到token的符号$ f+ {3 O8 N1 R3 [6 w# ]

. n( O0 U7 w& E& P/ n* x. b    decimals7 f2 }# Z$ W$ |: ?* Q
' p8 J" |# [" p5 ~
    functiondecimals()constantreturns(uint8_decimals); I9 h' R% @; Z2 O. |

% X4 A0 j- l( N1 Z7 A) ?5 j( k, j    得到token的小数点后几位. R2 r, R# s' y0 P* s

0 w, s* i( `% g  |" p    balanceOf
) M; u7 N* S, F- X4 B/ @
& j9 p- t7 c( Y8 J) ^    functionbalanceOf(address_owner)constantreturns(uint256balance)6 h& u9 w" D4 p! n, ?, W
; z9 g3 Z0 e& f, Q
    得到地址是_owner的账户的余额2 ~7 _- O' k& X4 i

* j4 Q2 I7 N1 O( y" k8 H    transfer(address,uint)
# f- \1 C. G5 h* n& F. s
8 c# U; s0 R5 {    functiontransfer(address_to,uint_value)returns(bool)' g0 I$ _+ o! s5 I: j
2 G- O8 `8 F; ~1 I' Z- s" S1 E8 v% e
    由于向后兼容性原因,因为ERC20传输函数没有字节参数。如果_to是合约,则此函数必须传输令牌并调_to中的函数tokenFallback(address,uint256,bytes)。如果_to(接收方合同)中没有实现tokenFallback函数,则事务必须失败,并且不会发生令牌的传输。
2 @. _4 i; ~: S/ L2 y8 T  W1 N  A
% m+ k* u& u9 Y  y8 G* T3 g    重要:将在接收方合约中调用的令牌备用功能必须命名为tokenFallback,并使用参数address,uint256,bytes。此函数必须具有0xc0ee0b8a签名。
% w% M# T( z7 u' Y2 {6 Q
& m6 t' l* c9 F  c9 j* M& v6 i    transfer(address,uint,bytes)
+ R0 \7 J) h( a6 a- x* i. X+ s0 c  R- T- A0 ~& x6 K
    functiontransfer(address_to,uint_value,bytes_data)returns(bool)5 O; y8 ]8 C9 ]; f
0 Z; l( f" W" x) m: @$ `4 W
    当某人想要转移令牌时总是调用这个函数。' a( x# i; R( v9 k# h' L

* V: G8 w* \8 E. X  M5 q$ _9 U9 p    如果_to是合约,则此函数必须传输令牌并调用_to中的函数tokenFallback(address,uint256,bytes)。如果_to(接收方合同)中没有实现tokenFallback函数,则事务必须失败,并且不会发生令牌的传输。
+ |1 x2 C, u: [" @( b1 t' E6 ~
) @- [0 M/ h" |. Z0 l1 g    如果_to是外部拥有的地址,则必须发送事务,而不尝试在_to中执行tokenFallback。
" R" N' G* q& a" [8 Y3 j! e8 y
7 R: z- N3 j6 r  s    _data可以附加到这个令牌交易中,它将永远保持在块状(需要更多的gas)。_data可以是空的。
4 q, z) t" f& n1 O( @
' A/ G0 {$ N  e7 A    注意:检查_to是合约还是地址的推荐方法是组装_to的代码。如果_to中没有代码,那么这是一个外部拥有的地址,否则就是一个合约。% s( Q: V2 O/ d

7 Z# ~4 [0 z* f1 q+ W. k    重要:将在接收方合约中调用的令牌备用功能必须命名为tokenFallback,并使用参数address,uint256,bytes。此函数必须具有0xc0ee0b8a签名。
( N8 v! |0 A5 h4 T* ?! s7 X& t  M" d. b; L( h  k
    事件8 Y" e4 f( o' }/ |1 j3 W- E
4 ]  X9 Q0 o  ]. S+ ~' Y/ \
    Transfer
4 O  T# e/ A- k  K* L6 R, T, x! i5 }
    eventTransfer(addressindexed_from,addressindexed_to,uint256indexed_value,bytes_data)# i) i* |8 e) X4 N+ W# l7 N9 B% k

) E. _6 g8 Q; G! m* b    当token转移的时候触发。
% Q2 ]( x) x1 Z
, e$ Y5 r+ t: w3 |6 r    合约和token一起工作
7 g& O* E  [& D8 N  w( ]. M& Q
2 k% m  B! f: K3 E$ C    functiontokenFallback(address_from,uint_value,bytes_data)
: U5 Q5 G0 S) ~' n/ U- n
6 C0 }0 Q! T) e0 T) _    令牌持有者发送令牌时处理从令牌合同所调用的令牌传输的功能。_from是令牌发送者,_value是传入令牌的数量,_data是附加的数据,类似于Ether事务中的数据。适用于以太交易的回退功能,并且不返回任何内容。5 v1 m  L7 J) n
$ }- l& u. x) C9 ?
    注意:msg.sender将是tokenFallback函数内的令牌合同。过滤哪些令牌(通过令牌契约地址)发送可能很重要。令牌发送者(谁发起了代币交易的人)将_fromthetokenFallback函数内。. Z: [6 B4 ?+ W( S& ]
4 G" |( I7 u5 ]+ L2 x. b
    重要:这个函数必须命名为tokenFallback,并使用参数地址uint256,字节来匹配函数签名0xc0ee0b8a。0 P1 n/ I, p5 ?

. B, j' ~5 l" g6 l    示例代码2 X9 h! q2 f7 w. Z$ m
# ^" ^1 l$ k$ k! r- K
    ERC223_Interface.sol
1 x+ b6 Z. I; j0 ^9 q5 N5 a) z9 e. _' c$ m) M5 y
    pragmasolidity^0.4.9;
2 E8 {+ ], w0 M" G+ |  p; I% l6 T. j0 [8 g$ W( n
    /*新的ERC23contract接口文件*/" h& j: J) A6 H- D/ D; ~" H

! l+ O' y1 E5 T* Z% T) l% j    contractERC223{
" n( I7 w5 @6 @
" s! B4 o$ s2 v2 x& p, \' A    uintpublictotalSupply;8 e' i* C2 d/ d) j/ _, m7 J
* ?, Q. v  U# x. }: x4 m  u; L4 B
    functionbalanceOf(addresswho)constantreturns(uint);
% _. I( S  L7 n% \5 |' ]
6 z* b8 G' ^. g% G  z5 P6 j/ \2 ?    functionname()constantreturns(string_name);
* \. u3 z4 {4 S$ @# @
7 @  j8 L' S% R2 ]0 d* m    functionsymbol()constantreturns(string_symbol);
* i' m8 e, z8 X+ u! Y* L9 b8 o0 {( T  J6 C4 l) I
    functiondecimals()constantreturns(uint8_decimals);% t+ c# s2 Q* c) ~2 r8 C5 O8 `

3 d& e- u" b4 a, s& \    functiontotalSupply()constantreturns(uint256_supply);
# L/ }0 i; l. k8 _5 b3 x" L- S# @! w" P& a: `' ?9 H
    functiontransfer(addressto,uintvalue)returns(boolok);! E3 w& e! b; }' L4 x- ^( z+ y, B0 V% C
: {; x5 i/ h5 p7 u: ^2 O
    functiontransfer(addressto,uintvalue,bytesdata)returns(boolok);; n5 p5 _" M+ L: E; r

# a- A4 J1 o" h. p# T    functiontransfer(addressto,uintvalue,bytesdata,stringcustom_fallback)returns(boolok);
8 m( B  b+ x1 B. Z5 S' F2 i( p( E) _! t" E
    eventTransfer(addressindexedfrom,addressindexedto,uintvalue,bytesindexeddata);
5 P9 j6 Z# z& G& Q  W9 N" {' ~$ B) G! R
/ ]" ?% t. }1 K# a/ _/ C* A. k    }
. [" {: o4 N8 Q% W$ G, q9 P$ K& H$ X# G2 e
    Receiver_Interface.sol' f; h6 n+ r9 ~3 ]/ ?: K% i
% ?$ I1 @# l: O  r% a* j( T
    pragmasolidity^0.4.9;
, V' I2 n* F6 j+ f0 [) b+ A9 Z0 Q
    /*
8 H$ C$ z' W% c! |3 t5 r
8 `: j% M, D+ y    *ContractthatisworkingwithERC223tokens+ I; x+ E8 ?* c# L

( j( R+ p, I- s5 e! f+ ^    */4 A- }- B+ d5 k) e9 C  B9 N

+ |. A5 y# U+ h- Z6 f% U    contractContractReceiver{
/ U4 N$ `1 w3 K4 a8 N, s  Z) C$ A; O- H3 A5 U7 b
    structTKN{
8 a% M7 G6 E! b4 o7 A  Y7 z
& a! U4 {4 D& q. I* l& \    addresssender;//调用合约的人
% W. U& w/ ?% `# A! |8 V5 b5 A& ?! B0 J6 J2 B
    uintvalue;
* f' Y+ W7 V7 k! _
7 Y5 C; R" Q6 k% m. j* S    bytesdata;& F2 t- W' n( Z5 I2 a0 q3 t( T. _: [
7 M2 @4 U2 K- e. C
    bytes4sig;//签名8 `. k* Z' m- M( U/ B7 F$ T+ q' ^; w
! l" ^- J. c* x6 |
    }, l% l: L, }) a8 }

6 Z/ `. j( |. N. m  u    functiontokenFallback(address_from,uint_value,bytes_data){5 m) [) ^( R+ R
8 v) X9 {& J) ]: L
    TKNmemorytkn;8 V' Q2 l! w1 ~( y8 x4 e0 q
9 p. [: a5 q+ e% |! w$ j# I% `
    tkn.sender=_from;
2 Q0 x7 R" n- Z& E
4 \8 e: B+ s- t5 f1 x7 O+ I    tkn.value=_value;. H! w5 h6 M- W9 D9 x: M" H

; r3 V0 p% x$ w. b0 A    tkn.data=_data;, F' _; V$ J" s: d* X% m: `

7 y" s! n! ?2 G( o    uint32u=uint32(_data[3])+(uint32(_data[2])( R  u# m/ Q6 A( O9 }0 i

# A" S4 |7 w6 }$ y9 v    ERC223_Token.sol
: M! m# u# F9 ^' `& |4 G9 F: m3 L6 ?! G1 S' v
    pragmasolidity^0.4.9;
6 {* x/ Y8 V) k, n4 K  d5 \; j; u2 W: Y& v1 n6 ^; ^* Y+ Q. N
    import"./Receiver_Interface.sol";6 Y# A) X* ^9 G2 Y' |0 o

5 T6 I" [. c/ {    import"./ERC223_Interface.sol";  N  g2 t& W; x, y

1 N8 z7 @1 x+ q( i    /**
( O6 Z. Y5 ]( J/ f+ d1 f$ u0 q' ^  }+ f9 N! i; a
    *ERC23tokenbyDexaran
- O2 Y, q& Z5 B- K0 s* H
3 H, Y1 Y) {0 F( U9 a7 ]    *4 Y) h  s" c/ N1 z1 z; f
5 u! d7 m- N" @+ O# h
    *https://github.com/Dexaran/ERC23-tokens
. _% B  F/ ^! P+ ~0 t3 U$ B8 G4 m+ O% c: {+ q1 ]
    */
! M+ D5 d3 G& w# z5 F
0 W# a" c1 B0 `3 \( v0 l    /*https://github.com/LykkeCity/Eth ... /token/SafeMath.sol*/( d4 ^/ L  d% q6 W

) R* @; {2 y+ V  p/ m; P) l' N    contractSafeMath{
9 s3 s& \* `$ p8 y1 _
, u* ~1 G1 e# f" b1 A" ^" y    uint256constantpublicMAX_UINT256=
; Y' E& {: L6 |: Y
/ _$ M3 v4 t+ _( C2 Y1 }    0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;* y' I% U$ w/ ]# l* g* h
" C6 {1 d% G8 v5 T" C- i
    functionsafeAdd(uint256x,uint256y)constantinternalreturns(uint256z){
2 @8 L* T, ~  _9 G  Z3 _+ z8 V3 }, ?4 b. h9 q2 B; l
    if(x>MAX_UINT256-y)throw;
/ e) l. O4 W2 {( b  |7 t: v7 \5 u& i' F' `! x; x
    returnx+y;
- e* x9 c/ D8 M8 g. X$ ]0 W' v5 F1 G7 a2 t
    }9 k7 F9 b2 k  b$ I- a1 T: O

2 @3 E2 M( g6 h7 Y    functionsafeSub(uint256x,uint256y)constantinternalreturns(uint256z){
: w: m! C, L: r9 ]6 G' R: m* I
, E$ X* y. |1 f5 I/ a" C    if(xMAX_UINT256/y)throw;
: m  N( ~7 q* A1 _! s" ^1 h4 b2 O' C( }
    returnx*y;% l  h/ `" J# Q$ o+ n, `- ]# F* T9 u
1 J; d2 w( E# d5 t
    }
8 G$ g) C/ `- O% E2 ]1 j! f
) T9 i, h% ?8 m' ?& a: t    }
  |" u- L3 U8 Y! V' |" s; H& d
1 f; o1 p+ a, M( G; c    //示例的智能合约代码
8 j4 S; A* C' w0 F" Q: e+ P$ U5 P+ `9 m; \' m0 U
    contractERC223TokenisERC223,SafeMath{3 x6 L( b3 z! S4 g
4 k* r) M. `9 [
    mapping(address=>uint)balances;3 C: m* U1 P9 }, [( P% ]- k

+ r4 ~- T7 b7 ^5 y$ a" B8 ?  m    stringpublicname;* t% L. Z9 P) q

) Q) Z) W. p2 @0 k    stringpublicsymbol;! t7 B" E8 g' [  O# |9 P% O
  A" \# [/ e! C5 U2 @
    uint8publicdecimals;
. }6 A1 ~* O2 H$ }) s
2 Q3 C( _; O/ U    uint256publictotalSupply;
" i3 J5 @+ x$ ~& J) _
+ b6 X& ^% G# D% E4 H2 e0 W: P9 P4 p    //获取token的名称6 |6 i0 E. Q& s9 f* J3 [
8 a7 ~  }" |1 v# Z7 C" |* d* O
    functionname()constantreturns(string_name){
/ n1 Y: j! q$ G) b* t: k
2 g9 w. P' x0 T; g3 t1 P    returnname;
& l* I' V( r" m/ k% O
; d+ \( O- [% d    }5 S# c, Z) z- V$ e3 F+ B7 v

7 R/ D8 `# }* H    //获取token的符号
* L7 M* |, t6 \: k3 n8 c1 S" t3 E1 K6 z# G
    functionsymbol()constantreturns(string_symbol){
1 d0 F0 ~$ t  E+ w" \# `! q  P/ q( d3 ~5 A
    returnsymbol;
3 C" ^" M' R% T6 y9 h) P  A! d
+ z. l5 h( a, }9 K: l9 O    }
  r; ^; C: X; ~7 X! N+ L4 w9 `& u$ Y; s" |% }3 ?; u
    //获取token精确到小数点后的位数" C; ^5 j! S6 J% C# B
+ T  @( T) x' \
    functiondecimals()constantreturns(uint8_decimals){
  }& ?5 x/ p9 c2 ?0 g% X
. W" m3 w- X8 X, B6 S, e    returndecimals;# k% u5 K. n# y" Q2 i! I( m- Z& U
3 P6 I  N& {3 M, K0 Y1 |
    }: Q2 Y% x+ W1 Q! P% F
0 f% W& X0 _" A( g6 m$ l
    //获取token的发布总量9 a+ s+ f( J! @, r3 D; V5 Y
8 |7 i: o1 k+ I) o/ n
    functiontotalSupply()constantreturns(uint256_totalSupply){* w3 j- d; d" X9 s$ O

3 ~- j5 H9 M" `* m, Q% S( N2 q- z    returntotalSupply;# \9 C! F8 D+ |$ p, Z

  z5 I4 B2 b' W, t6 J/ e    }
* j8 v8 V4 G. w/ Q3 V) b
% M2 [; r+ V+ z' F9 v    //当用户或其他合同想要转移资金时调用的功能。- s( Y! ~0 J* A' Z$ @

1 ~; U! w+ Y4 Z/ F6 g$ Z( A    functiontransfer(address_to,uint_value,bytes_data,string_custom_fallback)returns(boolsuccess){
5 W% O* u0 E$ g) M( c/ R% u" z# P, K/ b4 J/ T5 i
    //如果to是合约
5 A2 [* m, A3 X$ V( e: R& o" A$ t# k, r( b) Z
    if(isContract(_to)){
2 I. x% ^& o7 t8 g7 V5 I7 a% _$ }
/ J4 ^  O. W8 h3 k5 f/ [    if(balanceOf(msg.sender)0);
: @: T' y$ C/ f2 [' p8 M1 N+ C$ Q: }$ K" G, F' \# \. p  l; N
    }
+ o$ g7 t3 G' {9 E& ^% h
, c, E6 z+ k6 S! Z    //当传递目标是一个地址时调用函数
8 i* h. q/ D( t) D
2 \! }  C5 i- B: t# |% s    functiontransferToAddress(address_to,uint_value,bytes_data)privatereturns(boolsuccess){
  O7 P9 L+ ^: q6 t, H8 Z
+ I# n& C, G1 |9 P5 F, t* S( X    if(balanceOf(msg.sender)
BitMere.com 比特池塘系信息发布平台,比特池塘仅提供信息存储空间服务。
声明:该文观点仅代表作者本人,本文不代表比特池塘立场,且不构成建议,请谨慎对待。
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

成为第一个吐槽的人

真无牙泛 初中生
  • 粉丝

    1

  • 关注

    0

  • 主题

    26