DeploySEALED
▪&?╳**?~╲!%▓▫@◇▪●@■◆◆~^$◇◆▪▫~@○~╱▫□@◇█~▫▪▪◆░◇□▒$$▓!○■&▪○@#█$?▫$@
Transaction ID
Execution Fee
0.00000674 FLOWTransaction Summary
DeployContract deployment
Contract deployment
Script Arguments
0nameString
XpToken
1codeString
/// Testnet
/// import FungibleToken from 0x9a0766d93b6608b7
/// Mainnet
import FungibleToken from 0xf233dcee88fe0abe
import MetadataViews from 0x1d7e57aa55817448
import FungibleTokenMetadataViews from 0xf233dcee88fe0abe
access(all) contract XpToken: FungibleToken {
access(all) var totalSupply: UFix64
access(all) let VaultReceiverPath: PublicPath
access(all) let VaultBalancePath: PublicPath
access(all) let VaultStoragePath: StoragePath
access(all) let AdminStoragePath: StoragePath
access(all) event TokensInitialized(initialSupply: UFix64)
access(all) event TokensWithdrawn(amount: UFix64, from: Address?)
access(all) event TokensDeposited(amount: UFix64, to: Address?)
access(all) event TokensMinted(amount: UFix64)
access(all) event TokensBurned(amount: UFix64)
access(all) event MinterCreated(allowedAmount: UFix64)
access(all) event BurnerCreated()
access(all) view fun getContractViews(resourceType: Type?): [Type] {
return [
Type<FungibleTokenMetadataViews.FTView>(),
Type<FungibleTokenMetadataViews.FTDisplay>(),
Type<FungibleTokenMetadataViews.FTVaultData>(),
Type<FungibleTokenMetadataViews.TotalSupply>()
]
}
access(all) fun resolveContractView(resourceType: Type?, viewType: Type): AnyStruct? {
switch viewType {
case Type<FungibleTokenMetadataViews.FTView>():
return FungibleTokenMetadataViews.FTView(
ftDisplay: self.resolveContractView(resourceType: nil, viewType: Type<FungibleTokenMetadataViews.FTDisplay>()) as! FungibleTokenMetadataViews.FTDisplay?,
ftVaultData: self.resolveContractView(resourceType: nil, viewType: Type<FungibleTokenMetadataViews.FTVaultData>()) as! FungibleTokenMetadataViews.FTVaultData?
)
case Type<FungibleTokenMetadataViews.FTDisplay>():
let media = MetadataViews.Media(
file: MetadataViews.HTTPFile(
url: "https://imgur.com/IG75YJ2.png"
),
mediaType: "image/png+xml"
)
let medias = MetadataViews.Medias([media])
return FungibleTokenMetadataViews.FTDisplay(
name: "XP Token",
symbol: "XP",
description: "XP Token",
externalURL: MetadataViews.ExternalURL("https://titpalace.xyz"),
logos: medias,
socials: {
"twitter": MetadataViews.ExternalURL("https://x.com/vertico_defi"),
"instagram": MetadataViews.ExternalURL("https://www.instagram.com/titpalace/")
}
)
case Type<FungibleTokenMetadataViews.FTVaultData>():
return FungibleTokenMetadataViews.FTVaultData(
storagePath: self.VaultStoragePath,
receiverPath: self.VaultReceiverPath,
metadataPath: self.VaultBalancePath,
receiverLinkedType: Type<&Vault>(),
metadataLinkedType: Type<&Vault>(),
createEmptyVaultFunction: (fun(): @{FungibleToken.Vault} {
return <- XpToken.createEmptyVault(vaultType: Type<@Vault>())
})
)
case Type<FungibleTokenMetadataViews.TotalSupply>():
return FungibleTokenMetadataViews.TotalSupply(
totalSupply: XpToken.totalSupply
)
}
return nil
}
access(all) resource Vault: FungibleToken.Vault {
access(all) var balance: UFix64
init(balance: UFix64) {
self.balance = balance
}
access(contract) fun burnCallback() {
if self.balance > 0.0 {
XpToken.totalSupply = XpToken.totalSupply - self.balance
}
self.balance = 0.0
}
access(all) view fun getViews(): [Type] {
return XpToken.getContractViews(resourceType: nil)
}
access(all) fun resolveView(_ view: Type): AnyStruct? {
return XpToken.resolveContractView(resourceType: nil, viewType: view)
}
access(all) view fun getSupportedVaultTypes(): {Type: Bool} {
let supportedTypes: {Type: Bool} = {}
supportedTypes[self.getType()] = true
return supportedTypes
}
access(all) view fun isSupportedVaultType(type: Type): Bool {
return self.getSupportedVaultTypes()[type] ?? false
}
access(all) view fun isAvailableToWithdraw(amount: UFix64): Bool {
return amount <= self.balance
}
access(all) fun withdraw(amount: UFix64): @Vault {
self.balance = self.balance - amount
return <- create Vault(balance: amount)
}
access(all) fun deposit(from: @{FungibleToken.Vault}) {
let vault <- from as! @XpToken.Vault
self.balance = self.balance + vault.balance
vault.balance = 0.0
destroy vault
}
access(all) fun createEmptyVault(): @Vault {
return <-create Vault(balance: 0.0)
}
}
access(all) fun createEmptyVault(vaultType: Type): @Vault {
return <- create Vault(balance: 0.0)
}
access(all) resource Minter {
access(all) var allowedAmount: UFix64
access(all) fun mintTokens(amount: UFix64): @XpToken.Vault {
pre {
amount > 0.0: "Amount minted must be greater than zero"
amount <= self.allowedAmount: "Amount minted must be less than the allowed amount"
}
XpToken.totalSupply = XpToken.totalSupply + amount
self.allowedAmount = self.allowedAmount - amount
emit TokensMinted(amount: amount)
return <- create Vault(balance: amount)
}
init(allowedAmount: UFix64) {
self.allowedAmount = allowedAmount
}
}
access(all) resource Burner {}
access(all) resource Administrator {
access(all) fun createNewMinter(allowedAmount: UFix64): @Minter {
emit MinterCreated(allowedAmount: allowedAmount)
return <- create Minter(allowedAmount: allowedAmount)
}
}
init() {
self.totalSupply = 444444444.0
self.VaultReceiverPath = /public/XpTokenReceiver
self.VaultBalancePath = /public/XpTokenBalance
self.VaultStoragePath = /storage/XpTokenVault
self.AdminStoragePath = /storage/XpTokenAdmin
let vault <- create Vault(balance: self.totalSupply)
emit TokensMinted(amount: vault.balance)
let exampleTokenCap = self.account.capabilities.storage.issue<&Vault>(self.VaultStoragePath)
self.account.capabilities.publish(exampleTokenCap, at: self.VaultBalancePath)
let receiverCap = self.account.capabilities.storage.issue<&Vault>(self.VaultStoragePath)
self.account.capabilities.publish(receiverCap, at: self.VaultReceiverPath)
self.account.storage.save(<-vault, to: self.VaultStoragePath)
let admin <- create Administrator()
self.account.storage.save(<-admin, to: self.AdminStoragePath)
}
}
Cadence Script
1transaction(name: String, code: String ) {
2 prepare(signer: auth(AddContract) &Account) {
3 signer.contracts.add(name: name, code: code.utf8 )
4 }
5 }