/
A.051ccc1cc4035a46.CryptoLikeToken.cdc
201 lines (170 loc) · 7.23 KB
/
A.051ccc1cc4035a46.CryptoLikeToken.cdc
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
import FungibleToken from 0xf233dcee88fe0abe
pub contract CryptoLikeToken: FungibleToken {
// Total supply of Flow tokens in existence
pub var totalSupply: UFix64
// Event that is emitted when the contract is created
pub event TokensInitialized(initialSupply: UFix64)
// Event that is emitted when tokens are withdrawn from a Vault
pub event TokensWithdrawn(amount: UFix64, from: Address?)
// Event that is emitted when tokens are deposited to a Vault
pub event TokensDeposited(amount: UFix64, to: Address?)
// Event that is emitted when new tokens are minted
pub event TokensMinted(amount: UFix64)
// Event that is emitted when tokens are destroyed
pub event TokensBurned(amount: UFix64)
// Event that is emitted when a new minter resource is created
pub event MinterCreated(allowedAmount: UFix64)
// Event that is emitted when a new burner resource is created
pub event BurnerCreated()
// Vault
//
// Each user stores an instance of only the Vault in their storage
// The functions in the Vault and governed by the pre and post conditions
// in FungibleToken when they are called.
// The checks happen at runtime whenever a function is called.
//
// Resources can only be created in the context of the contract that they
// are defined in, so there is no way for a malicious user to create Vaults
// out of thin air. A special Minter resource needs to be defined to mint
// new tokens.
//
pub resource Vault: FungibleToken.Provider, FungibleToken.Receiver, FungibleToken.Balance {
// holds the balance of a users tokens
pub var balance: UFix64
// initialize the balance at resource creation time
init(balance: UFix64) {
self.balance = balance
}
// withdraw
//
// Function that takes an integer amount as an argument
// and withdraws that amount from the Vault.
// It creates a new temporary Vault that is used to hold
// the money that is being transferred. It returns the newly
// created Vault to the context that called so it can be deposited
// elsewhere.
//
pub fun withdraw(amount: UFix64): @FungibleToken.Vault {
self.balance = self.balance - amount
emit TokensWithdrawn(amount: amount, from: self.owner?.address)
return <-create Vault(balance: amount)
}
// deposit
//
// Function that takes a Vault object as an argument and adds
// its balance to the balance of the owners Vault.
// It is allowed to destroy the sent Vault because the Vault
// was a temporary holder of the tokens. The Vault's balance has
// been consumed and therefore can be destroyed.
pub fun deposit(from: @FungibleToken.Vault) {
let vault <- from as! @CryptoLikeToken.Vault
self.balance = self.balance + vault.balance
emit TokensDeposited(amount: vault.balance, to: self.owner?.address)
vault.balance = 0.0
destroy vault
}
destroy() {
if self.balance > 0.0 {
CryptoLikeToken.totalSupply = CryptoLikeToken.totalSupply - self.balance
}
}
}
// createEmptyVault
//
// Function that creates a new Vault with a balance of zero
// and returns it to the calling context. A user must call this function
// and store the returned Vault in their storage in order to allow their
// account to be able to receive deposits of this token type.
//
pub fun createEmptyVault(): @FungibleToken.Vault {
return <-create Vault(balance: 0.0)
}
pub resource Administrator {
// createNewMinter
//
// Function that creates and returns a new minter resource
//
pub fun createNewMinter(allowedAmount: UFix64): @Minter {
emit MinterCreated(allowedAmount: allowedAmount)
return <-create Minter(allowedAmount: allowedAmount)
}
// createNewBurner
//
// Function that creates and returns a new burner resource
//
pub fun createNewBurner(): @Burner {
emit BurnerCreated()
return <-create Burner()
}
}
// Minter
//
// Resource object that token admin accounts can hold to mint new tokens.
//
pub resource Minter {
// the amount of tokens that the minter is allowed to mint
pub var allowedAmount: UFix64
// mintTokens
//
// Function that mints new tokens, adds them to the total supply,
// and returns them to the calling context.
//
pub fun mintTokens(amount: UFix64): @CryptoLikeToken.Vault {
pre {
amount > UFix64(0): "Amount minted must be greater than zero"
amount <= self.allowedAmount: "Amount minted must be less than the allowed amount"
}
CryptoLikeToken.totalSupply = CryptoLikeToken.totalSupply + amount
self.allowedAmount = self.allowedAmount - amount
emit TokensMinted(amount: amount)
return <-create Vault(balance: amount)
}
init(allowedAmount: UFix64) {
self.allowedAmount = allowedAmount
}
}
// Burner
//
// Resource object that token admin accounts can hold to burn tokens.
//
pub resource Burner {
// burnTokens
//
// Function that destroys a Vault instance, effectively burning the tokens.
//
// Note: the burned tokens are automatically subtracted from the
// total supply in the Vault destructor.
//
pub fun burnTokens(from: @FungibleToken.Vault) {
let vault <- from as! @CryptoLikeToken.Vault
let amount = vault.balance
destroy vault
emit TokensBurned(amount: amount)
}
}
init() {
self.totalSupply = 0.0
// Create the Vault with the total supply of tokens and save it in storage
//
let vault <- create Vault(balance: self.totalSupply)
self.account.save(<-vault, to: /storage/CryptoLikeTokenVault)
// Create a public capability to the stored Vault that only exposes
// the `deposit` method through the `Receiver` interface
//
self.account.link<&CryptoLikeToken.Vault{FungibleToken.Receiver}>(
/public/CryptoLikeTokenReceiver,
target: /storage/CryptoLikeTokenVault
)
// Create a public capability to the stored Vault that only exposes
// the `balance` field through the `Balance` interface
//
self.account.link<&CryptoLikeToken.Vault{FungibleToken.Balance}>(
/public/CryptoLikeTokenBalance,
target: /storage/CryptoLikeTokenVault
)
let admin <- create Administrator()
self.account.save(<-admin, to: /storage/CryptoLikeTokenAdmin)
// Emit an event that shows that the contract was initialized
emit TokensInitialized(initialSupply: self.totalSupply)
}
}