StakingContract_V2

1import FungibleToken from 0xf233dcee88fe0abe
2import FlowToken from 0x1654653399040a61
3
4access(all) contract StakingContract_V2 {  
5    access(self) var historyStats: {Address: [HistoryStats]}
6 
7    access(all) resource Staking {
8        access(all) var stakedAmount: UFix64
9        access(all) var releasedAmount: UFix64
10        access(all) let vault: @{FungibleToken.Vault}
11        access(all) let flowVault: @{FungibleToken.Vault} 
12
13        init(vault: @{FungibleToken.Vault}) {
14            self.stakedAmount = 0.0
15            self.releasedAmount = 0.0
16            self.vault <- vault 
17            self.flowVault <- FlowToken.createEmptyVault(vaultType: Type<@FlowToken.Vault>())
18        }
19 
20        access(all) fun stake(address: &Account, amount: UFix64, timeCommitted: UInt64) {
21            self.flowVault.deposit(from: <- self.vault.withdraw(amount: amount))
22            self.stakedAmount = amount   
23            if StakingContract_V2.historyStats[address.address] == nil {
24                StakingContract_V2.historyStats[address.address] = []
25            }
26            StakingContract_V2.historyStats[address.address]!.append(HistoryStats(totalStaked: amount, timeCommitted: timeCommitted))
27        } 
28 
29        access(all) fun cleanup(address: &Account): @{FungibleToken.Vault} {
30            let remainingAmount: UFix64 = self.stakedAmount
31            self.stakedAmount = 0.0  
32            let historyStats: [HistoryStats]? = StakingContract_V2.historyStats[address.address]
33            if historyStats != nil {
34                if historyStats!.length > 0 {
35                    var mutableHistoryStats: [StakingContract_V2.HistoryStats] = historyStats!
36                    let lastHistory: StakingContract_V2.HistoryStats = mutableHistoryStats[mutableHistoryStats.length - 1]
37                    lastHistory.end()
38                    mutableHistoryStats[mutableHistoryStats.length - 1] = lastHistory
39                    StakingContract_V2.historyStats[address.address] = mutableHistoryStats
40                }
41            }
42
43            return <- self.flowVault.withdraw(amount: remainingAmount)
44        } 
45    }     
46
47    access(all) struct HistoryStats {
48        access(self) let startDate: UInt64
49        access(self) var endDate: UInt64
50        access(self) let totalStaked: UFix64
51        access(self) var totalUnstaked: UFix64
52        access(self) let timeCommitted: UInt64
53
54        init(totalStaked: UFix64, timeCommitted: UInt64) {
55            self.startDate = UInt64(getCurrentBlock().timestamp)
56            self.totalStaked = totalStaked 
57            self.timeCommitted = timeCommitted
58            self.endDate = 0
59            self.totalUnstaked = 0.0
60        } 
61
62        access(all) fun end() {
63            self.endDate = UInt64(getCurrentBlock().timestamp) 
64            self.totalUnstaked = self.totalStaked
65        }
66    }
67
68    init() {
69        self.historyStats = {}
70    }
71 
72    access(all) fun createStaking(vault: @{FungibleToken.Vault}): @Staking {
73        return <- create Staking(vault: <- vault)
74    }  
75
76    access(all) fun getStats(address: Address): [HistoryStats]? {
77        return self.historyStats[address]
78    }
79}