Add wflow handler

README.md

@@ -88,9 +88,17 @@ side, it must escrow on the other as the native VM contract is owned by an exter
 
 With fungible tokens in particular, there may be some cases where the Cadence contract is not deployed to the bridge
 account, but the bridge still follows a mint/burn pattern in Cadence. These cases are handled via
-[`TokenHandler`](./cadence/contracts/bridge/interfaces/FlowEVMBridgeHandlerInterfaces.cdc) implementations. Also know
-that moving $FLOW to EVM is built into the `EVMAddress` object so any requests bridging $FLOW to EVM will simply
-leverage this interface; however, moving $FLOW from EVM to Cadence must be done through the COA resource.
+[`TokenHandler`](./cadence/contracts/bridge/interfaces/FlowEVMBridgeHandlerInterfaces.cdc) implementations.
+
+Also know that moving $FLOW to EVM is built into the `EVMAddress` object via `EVMAddress.deposit(from: @FlowToken.Vault)`.
+Conversely, moving $FLOW from EVM is facilitated via the `CadenceOwnedAccount.withdraw(balance: Balance): @FlowToken.Vault`
+method. Given these existing interfaces, the bridge instead handles $FLOW as corresponding fungible token
+implementations - `FungibleToken.Vault` in Cadence & ERC20 in EVM. Therefore, the bridge wraps $FLOW en route to EVM
+(depositing WFLOW to the recipient) and unwraps WFLOW when bridging when moving from EVM. In short, the cross-VM
+association for $FLOW as far as the bridge is concerned is `@FlowToken.Vault` <> WFLOW
+(`0xd3bF53DAC106A0290B0483EcBC89d40FcC961f3e` on
+[Testnet](https://evm-testnet.flowscan.io/address/0xd3bF53DAC106A0290B0483EcBC89d40FcC961f3e) &
+[Mainnet](https://evm.flowscan.io/address/0xd3bF53DAC106A0290B0483EcBC89d40FcC961f3e)).
 
 Below are transactions relevant to bridging fungible tokens:
 - [`bridge_tokens_to_evm.cdc`](./cadence/transactions/bridge/tokens/bridge_tokens_to_evm.cdc)

cadence/contracts/bridge/FlowEVMBridge.cdc

@@ -69,8 +69,6 @@ contract FlowEVMBridge : IFlowEVMNFTBridge, IFlowEVMTokenBridge {
     fun onboardByType(_ type: Type, feeProvider: auth(FungibleToken.Withdraw) &{FungibleToken.Provider}) {
         pre {
             !FlowEVMBridgeConfig.isPaused(): "Bridge operations are currently paused"
-            type != Type<@FlowToken.Vault>():
-                "$FLOW cannot be bridged via the VM bridge - use the CadenceOwnedAccount interface"
             self.typeRequiresOnboarding(type) == true: "Onboarding is not needed for this type"
             FlowEVMBridgeUtils.typeAllowsBridging(type):
                 "This type is not supported as defined by the project's development team"
@@ -353,11 +351,6 @@ contract FlowEVMBridge : IFlowEVMNFTBridge, IFlowEVMTokenBridge {
         /* Handle $FLOW requests via EVM interface & return */
         //
         let vaultType = vault.getType()
-        if vaultType == Type<@FlowToken.Vault>() {
-            let flowVault <-vault as! @FlowToken.Vault
-            to.deposit(from: <-flowVault)
-            return
-        }
 
         // Gather the vault balance before acting on the resource
         let vaultBalance = vault.balance
@@ -446,7 +439,6 @@ contract FlowEVMBridge : IFlowEVMNFTBridge, IFlowEVMTokenBridge {
         pre {
             !FlowEVMBridgeConfig.isPaused(): "Bridge operations are currently paused"
             !type.isSubtype(of: Type<@{NonFungibleToken.Collection}>()): "Mixed asset types are not yet supported"
-            !type.isInstance(Type<@FlowToken.Vault>()): "Must use the CadenceOwnedAccount interface to bridge $FLOW from EVM"
             self.typeRequiresOnboarding(type) == false: "FungibleToken must first be onboarded"
             FlowEVMBridgeConfig.isTypePaused(type) == false: "Bridging is currently paused for this token"
         }

cadence/contracts/bridge/FlowEVMBridgeConfig.cdc

@@ -453,7 +453,7 @@ contract FlowEVMBridgeConfig {
         access(FlowEVMBridgeHandlerInterfaces.Admin)
         fun enableHandler(targetType: Type) {
             let handler = FlowEVMBridgeConfig.borrowTokenHandlerAdmin(targetType)
-                ?? panic("No handler found for target Type")
+                ?? panic("No handler found for target Type ".concat(targetType.identifier))
             handler.enableBridging()
 
             let targetEVMAddressHex = handler.getTargetEVMAddress()?.toString()
@@ -465,6 +465,26 @@ contract FlowEVMBridgeConfig {
                 isEnabled: handler.isEnabled()
             )
         }
+
+        /// Disables the TokenHandler for the given Type. If a TokenHandler does not exist for the given Type, the
+        /// operation reverts.
+        ///
+        /// @param targetType: Cadence type indexing the relevant TokenHandler
+        ///
+        /// @emits HandlerConfigured with the target Type, target EVM address, and whether the handler is enabled
+        ///
+        access(FlowEVMBridgeHandlerInterfaces.Admin)
+        fun disableHandler(targetType: Type) {
+            let handler = FlowEVMBridgeConfig.borrowTokenHandlerAdmin(targetType)
+                ?? panic("No handler found for target Type".concat(targetType.identifier))
+            handler.disableBridging()
+
+            emit HandlerConfigured(
+                targetType: handler.getTargetType()!.identifier,
+                targetEVMAddress: handler.getTargetEVMAddress()?.toString(),
+                isEnabled: handler.isEnabled()
+            )
+        }
     }
 
     init() {
@@ -474,16 +494,8 @@ contract FlowEVMBridgeConfig {
         self.gasLimit = 15_000_000
         self.paused = true
 
-        // Although $FLOW does not have ERC20 address, we associate the the Vault with the EVM address from which
-        // EVM transfers originate
-        // See FLIP #223 - https://github.com/onflow/flips/pull/225
-        let flowOriginationAddress = EVM.EVMAddress(
-                bytes: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]
-            )
-        let flowVaultType = Type<@FlowToken.Vault>()
-        let flowOriginationAddressHex = flowOriginationAddress.toString()
-        self.registeredTypes = { flowVaultType: TypeEVMAssociation(associated: flowOriginationAddress) }
-        self.evmAddressHexToType = { flowOriginationAddressHex: flowVaultType }
+        self.registeredTypes = {}
+        self.evmAddressHexToType = {}
 
         self.typeToTokenHandlers <- {}