DeploySEALED
▒◆╲╱▓█%█?~○@●**□&█$^╳▓█▒$#@╲╳$▒#%*▓▪*▫^~╱▓&▫╱░█@@◆╱▓◇╳?╱?#*^╱#╳╳
Transaction ID
Execution Fee
0.0025 FLOWTransaction Summary
UpdatingDeploy
Contract deployment
Contract deployment
Script Arguments
Copy:
0contractNameString
TestingAgentToken
1contractCodeString
import FungibleToken from 0xf233dcee88fe0abe
import MetadataViews from 0x1d7e57aa55817448
import FungibleTokenMetadataViews from 0xf233dcee88fe0abe
import ViewResolver from 0x1d7e57aa55817448
access(all) contract TestingAgentToken: FungibleToken {
access(all) var totalSupply: UFix64
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) let VaultStoragePath: StoragePath
access(all) let VaultPublicPath: PublicPath
access(all) let ReceiverPublicPath: PublicPath
access(all) let MinterStoragePath: StoragePath
access(all) resource Vault: FungibleToken.Vault {
access(all) var balance: UFix64
init(balance: UFix64) {
self.balance = balance
}
access(FungibleToken.Withdraw) fun withdraw(amount: UFix64): @{FungibleToken.Vault} {
self.balance = self.balance - amount
emit TokensWithdrawn(amount: amount, from: self.owner?.address)
return <-create Vault(balance: amount)
}
access(all) fun deposit(from: @{FungibleToken.Vault}) {
let vault <- from as! @TestingAgentToken.Vault
self.balance = self.balance + vault.balance
emit TokensDeposited(amount: vault.balance, to: self.owner?.address)
vault.balance = 0.0
destroy vault
}
access(all) fun createEmptyVault(): @{FungibleToken.Vault} {
return <-create Vault(balance: 0.0)
}
access(all) view fun isAvailableToWithdraw(amount: UFix64): Bool {
return self.balance >= amount
}
access(all) view fun getViews(): [Type] {
return TestingAgentToken.getContractViews(resourceType: nil)
}
access(all) fun resolveView(_ view: Type): AnyStruct? {
return TestingAgentToken.resolveContractView(resourceType: nil, viewType: view)
}
}
access(all) resource Minter {
access(all) fun mintTokens(amount: UFix64): @Vault {
TestingAgentToken.totalSupply = TestingAgentToken.totalSupply + amount
emit TokensMinted(amount: amount)
return <-create Vault(balance: amount)
}
}
access(all) fun createEmptyVault(vaultType: Type): @{FungibleToken.Vault} {
return <-create Vault(balance: 0.0)
}
access(all) view fun getContractViews(resourceType: Type?): [Type] {
return [
Type<FungibleTokenMetadataViews.FTView>(),
Type<FungibleTokenMetadataViews.FTDisplay>(),
Type<FungibleTokenMetadataViews.FTVaultData>()
]
}
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>():
return FungibleTokenMetadataViews.FTDisplay(
name: "TestingAgentToken",
symbol: "TAT",
description: "A test fungible token deployed by an AI agent on Flow mainnet.",
externalURL: MetadataViews.ExternalURL("https://flow.com"),
logos: MetadataViews.Medias([]),
socials: {}
)
case Type<FungibleTokenMetadataViews.FTVaultData>():
return FungibleTokenMetadataViews.FTVaultData(
storagePath: TestingAgentToken.VaultStoragePath,
receiverPath: TestingAgentToken.ReceiverPublicPath,
metadataPath: TestingAgentToken.VaultPublicPath,
receiverLinkedType: Type<&TestingAgentToken.Vault>(),
metadataLinkedType: Type<&TestingAgentToken.Vault>(),
createEmptyVaultFunction: (fun(): @{FungibleToken.Vault} {
return <-TestingAgentToken.createEmptyVault(vaultType: Type<@TestingAgentToken.Vault>())
})
)
}
return nil
}
init() {
self.totalSupply = 1000000.0
self.VaultStoragePath = /storage/testingAgentTokenVault
self.VaultPublicPath = /public/testingAgentTokenMetadata
self.ReceiverPublicPath = /public/testingAgentTokenReceiver
self.MinterStoragePath = /storage/testingAgentTokenMinter
let vault <- create Vault(balance: self.totalSupply)
self.account.storage.save(<-vault, to: self.VaultStoragePath)
let receiverCap = self.account.capabilities.storage.issue<&TestingAgentToken.Vault>(self.VaultStoragePath)
self.account.capabilities.publish(receiverCap, at: self.ReceiverPublicPath)
let metadataCap = self.account.capabilities.storage.issue<&TestingAgentToken.Vault>(self.VaultStoragePath)
self.account.capabilities.publish(metadataCap, at: self.VaultPublicPath)
let minter <- create Minter()
self.account.storage.save(<-minter, to: self.MinterStoragePath)
emit TokensInitialized(initialSupply: self.totalSupply)
}
}
Cadence Script
1// FlowIndex Agent Wallet - v0.1.6 - mainnet
2
3transaction(contractName: String, contractCode: String) {
4 prepare(signer: auth(AddContract) &Account) {
5 signer.contracts.add(name: contractName, code: contractCode.utf8)
6 }
7}