TestingAgentToken

1import FungibleToken from 0xf233dcee88fe0abe
2import MetadataViews from 0x1d7e57aa55817448
3import FungibleTokenMetadataViews from 0xf233dcee88fe0abe
4import ViewResolver from 0x1d7e57aa55817448
5
6access(all) contract TestingAgentToken: FungibleToken {
7
8    access(all) var totalSupply: UFix64
9
10    access(all) event TokensInitialized(initialSupply: UFix64)
11    access(all) event TokensWithdrawn(amount: UFix64, from: Address?)
12    access(all) event TokensDeposited(amount: UFix64, to: Address?)
13    access(all) event TokensMinted(amount: UFix64)
14
15    access(all) let VaultStoragePath: StoragePath
16    access(all) let VaultPublicPath: PublicPath
17    access(all) let ReceiverPublicPath: PublicPath
18    access(all) let MinterStoragePath: StoragePath
19
20    access(all) resource Vault: FungibleToken.Vault {
21        access(all) var balance: UFix64
22
23        init(balance: UFix64) {
24            self.balance = balance
25        }
26
27        access(FungibleToken.Withdraw) fun withdraw(amount: UFix64): @{FungibleToken.Vault} {
28            self.balance = self.balance - amount
29            emit TokensWithdrawn(amount: amount, from: self.owner?.address)
30            return <-create Vault(balance: amount)
31        }
32
33        access(all) fun deposit(from: @{FungibleToken.Vault}) {
34            let vault <- from as! @TestingAgentToken.Vault
35            self.balance = self.balance + vault.balance
36            emit TokensDeposited(amount: vault.balance, to: self.owner?.address)
37            vault.balance = 0.0
38            destroy vault
39        }
40
41        access(all) fun createEmptyVault(): @{FungibleToken.Vault} {
42            return <-create Vault(balance: 0.0)
43        }
44
45        access(all) view fun isAvailableToWithdraw(amount: UFix64): Bool {
46            return self.balance >= amount
47        }
48
49        access(all) view fun getViews(): [Type] {
50            return TestingAgentToken.getContractViews(resourceType: nil)
51        }
52
53        access(all) fun resolveView(_ view: Type): AnyStruct? {
54            return TestingAgentToken.resolveContractView(resourceType: nil, viewType: view)
55        }
56    }
57
58    access(all) resource Minter {
59        access(all) fun mintTokens(amount: UFix64): @Vault {
60            TestingAgentToken.totalSupply = TestingAgentToken.totalSupply + amount
61            emit TokensMinted(amount: amount)
62            return <-create Vault(balance: amount)
63        }
64    }
65
66    access(all) fun createEmptyVault(vaultType: Type): @{FungibleToken.Vault} {
67        return <-create Vault(balance: 0.0)
68    }
69
70    access(all) view fun getContractViews(resourceType: Type?): [Type] {
71        return [
72            Type<FungibleTokenMetadataViews.FTView>(),
73            Type<FungibleTokenMetadataViews.FTDisplay>(),
74            Type<FungibleTokenMetadataViews.FTVaultData>()
75        ]
76    }
77
78    access(all) fun resolveContractView(resourceType: Type?, viewType: Type): AnyStruct? {
79        switch viewType {
80            case Type<FungibleTokenMetadataViews.FTView>():
81                return FungibleTokenMetadataViews.FTView(
82                    ftDisplay: self.resolveContractView(resourceType: nil, viewType: Type<FungibleTokenMetadataViews.FTDisplay>()) as! FungibleTokenMetadataViews.FTDisplay?,
83                    ftVaultData: self.resolveContractView(resourceType: nil, viewType: Type<FungibleTokenMetadataViews.FTVaultData>()) as! FungibleTokenMetadataViews.FTVaultData?
84                )
85            case Type<FungibleTokenMetadataViews.FTDisplay>():
86                return FungibleTokenMetadataViews.FTDisplay(
87                    name: "TestingAgentToken",
88                    symbol: "TAT",
89                    description: "A test fungible token deployed by an AI agent on Flow mainnet.",
90                    externalURL: MetadataViews.ExternalURL("https://flow.com"),
91                    logos: MetadataViews.Medias([]),
92                    socials: {}
93                )
94            case Type<FungibleTokenMetadataViews.FTVaultData>():
95                return FungibleTokenMetadataViews.FTVaultData(
96                    storagePath: TestingAgentToken.VaultStoragePath,
97                    receiverPath: TestingAgentToken.ReceiverPublicPath,
98                    metadataPath: TestingAgentToken.VaultPublicPath,
99                    receiverLinkedType: Type<&TestingAgentToken.Vault>(),
100                    metadataLinkedType: Type<&TestingAgentToken.Vault>(),
101                    createEmptyVaultFunction: (fun(): @{FungibleToken.Vault} {
102                        return <-TestingAgentToken.createEmptyVault(vaultType: Type<@TestingAgentToken.Vault>())
103                    })
104                )
105        }
106        return nil
107    }
108
109    init() {
110        self.totalSupply = 1000000.0
111        self.VaultStoragePath = /storage/testingAgentTokenVault
112        self.VaultPublicPath = /public/testingAgentTokenMetadata
113        self.ReceiverPublicPath = /public/testingAgentTokenReceiver
114        self.MinterStoragePath = /storage/testingAgentTokenMinter
115
116        let vault <- create Vault(balance: self.totalSupply)
117        self.account.storage.save(<-vault, to: self.VaultStoragePath)
118
119        let receiverCap = self.account.capabilities.storage.issue<&TestingAgentToken.Vault>(self.VaultStoragePath)
120        self.account.capabilities.publish(receiverCap, at: self.ReceiverPublicPath)
121
122        let metadataCap = self.account.capabilities.storage.issue<&TestingAgentToken.Vault>(self.VaultStoragePath)
123        self.account.capabilities.publish(metadataCap, at: self.VaultPublicPath)
124
125        let minter <- create Minter()
126        self.account.storage.save(<-minter, to: self.MinterStoragePath)
127
128        emit TokensInitialized(initialSupply: self.totalSupply)
129    }
130}