AgentManager3

1import FungibleToken from 0xf233dcee88fe0abe
2import FlowToken from 0x1654653399040a61
3import stFlowToken from 0xd6f80565193ad727
4import EVM from 0xe467b9dd11fa00df
5import VaultCore from 0x79f5b5b0f95a160b
6
7/// AgentManager3 - Simplified version without nested strategy resources
8access(all) contract AgentManager3 {
9    
10    access(all) let AgentStoragePath: StoragePath
11    access(all) let AgentPublicPath: PublicPath
12    
13    access(all) event StrategyExecuted(strategy: String, amount: UFix64, result: String)
14    access(all) event FundsBridgedToEVM(amount: UFix64, evmAddress: String)
15    access(all) event FundsBridgedFromEVM(amount: UFix64)
16    
17    access(self) var totalBridgedToEVM: UFix64
18    access(self) var totalBridgedFromEVM: UFix64
19    
20    /// Simplified Agent - only manages vault and COA, strategies are stateless
21    access(all) resource Agent {
22        access(self) let vaultRef: &VaultCore.Vault
23        access(self) let coa: auth(EVM.Call, EVM.Withdraw) &EVM.CadenceOwnedAccount
24        
25        init(vaultRef: &VaultCore.Vault, coa: auth(EVM.Call, EVM.Withdraw) &EVM.CadenceOwnedAccount) {
26            self.vaultRef = vaultRef
27            self.coa = coa
28        }
29        
30        // Bridge functions work directly with vault and COA
31        access(all) fun bridgeToEVM(amount: UFix64): Bool {
32            let flowVault <- self.vaultRef.withdrawForEVMBridge(assetType: VaultCore.AssetType.flow, amount: amount) as! @FlowToken.Vault
33            self.coa.deposit(from: <-flowVault)
34            AgentManager3.totalBridgedToEVM = AgentManager3.totalBridgedToEVM + amount
35            emit FundsBridgedToEVM(amount: amount, evmAddress: self.coa.address().toString())
36            return true
37        }
38        
39        access(all) fun bridgeFromEVM(amount: UFix64): Bool {
40            let scaledAmount = amount * 1000000000.0
41            let amountUInt = UInt(scaledAmount) * 1000000000
42            let balance = EVM.Balance(attoflow: amountUInt)
43            let flowVault <- self.coa.withdraw(balance: balance) as! @FlowToken.Vault
44            let actualAmount = flowVault.balance
45            self.vaultRef.depositFromEVMBridge(from: <-flowVault)
46            AgentManager3.totalBridgedFromEVM = AgentManager3.totalBridgedFromEVM + actualAmount
47            emit FundsBridgedFromEVM(amount: actualAmount)
48            return true
49        }
50        
51        access(all) fun executeEVMStrategy(contractAddress: String, calldata: [UInt8], value: UFix64): EVM.Result {
52            let scaledValue = value * 1000000000.0
53            let amountUInt = UInt(scaledValue) * 1000000000
54            let balance = EVM.Balance(attoflow: amountUInt)
55            let addressBytes = contractAddress.decodeHex()
56            assert(addressBytes.length == 20, message: "Invalid EVM address")
57            let fixedBytes: [UInt8; 20] = [addressBytes[0], addressBytes[1], addressBytes[2], addressBytes[3], addressBytes[4], addressBytes[5], addressBytes[6], addressBytes[7], addressBytes[8], addressBytes[9], addressBytes[10], addressBytes[11], addressBytes[12], addressBytes[13], addressBytes[14], addressBytes[15], addressBytes[16], addressBytes[17], addressBytes[18], addressBytes[19]]
58            let evmAddress = EVM.EVMAddress(bytes: fixedBytes)
59            return self.coa.call(to: evmAddress, data: calldata, gasLimit: 10_000_000, value: balance)
60        }
61        
62        access(all) fun getCOAAddress(): String {
63            return self.coa.address().toString()
64        }
65        
66        access(all) fun getCOABalance(): UFix64 {
67            let balanceAttoflow = self.coa.balance().attoflow
68            let scaledDown = UFix64(balanceAttoflow / 1000000000)
69            return scaledDown / 1000000000.0
70        }
71        
72        access(all) fun getVaultAddress(): Address {
73            return self.vaultRef.owner!.address
74        }
75    }
76    
77    access(all) fun createAgent(vaultRef: &VaultCore.Vault, coa: auth(EVM.Call, EVM.Withdraw) &EVM.CadenceOwnedAccount): @Agent {
78        return <- create Agent(vaultRef: vaultRef, coa: coa)
79    }
80    
81    access(all) fun getMetrics(): {String: UFix64} {
82        return {"totalBridgedToEVM": self.totalBridgedToEVM, "totalBridgedFromEVM": self.totalBridgedFromEVM}
83    }
84    
85    init() {
86        self.AgentStoragePath = /storage/AgentManager3
87        self.AgentPublicPath = /public/AgentManager3
88        self.totalBridgedToEVM = 0.0
89        self.totalBridgedFromEVM = 0.0
90    }
91}