generalize create_cadence_native_token_handler

cadence/tests/flow_evm_bridge_handler_tests.cdc

@@ -289,7 +289,7 @@ fun testConfigureCadenceNativeTokenHandlerSucceeds() {
         code: Test.readFile("../transactions/bridge/admin/create_cadence_native_token_handler.cdc"),
         authorizers: [exampleHandledTokenAccount.address, bridgeAccount.address],
         signers: [exampleHandledTokenAccount, bridgeAccount],
-        arguments: [],
+        arguments: [exampleTokenIdentifier, /storage/exampleTokenAdmin],
     )
     let createHandlerResult = Test.executeTransaction(handlerSetupTxn)
     Test.expect(createHandlerResult, Test.beSucceeded())

cadence/transactions/bridge/admin/create_cadence_native_token_handler.cdc

@@ -1,28 +1,34 @@
 import "EVM"
 
-import "ExampleHandledToken"
-
 import "FlowEVMBridgeHandlerInterfaces"
 import "FlowEVMBridgeHandlers"
 
-transaction {
+/// Creates a new TokenHandler for a Cadence-native fungible token, pulling a TokenMinter resource from the provided
+/// storage path.
+///
+/// @param vaultIdentifier: The identifier of the vault to create the TokenHandler for
+/// @param minterStoragePath: The storage path to load the TokenMinter resource from
+///
+transaction(vaultIdentifier: String, minterStoragePath: StoragePath) {
 
     let configurator: auth(FlowEVMBridgeHandlerInterfaces.Admin) &FlowEVMBridgeHandlers.HandlerConfigurator
-    let minter: @ExampleHandledToken.Minter
+    let minter: @{FlowEVMBridgeHandlerInterfaces.TokenMinter}
 
     prepare(tokenMinter: auth(LoadValue) &Account, bridge: auth(BorrowValue, LoadValue) &Account) {
         self.configurator = bridge.storage.borrow<auth(FlowEVMBridgeHandlerInterfaces.Admin) &FlowEVMBridgeHandlers.HandlerConfigurator>(
                 from: FlowEVMBridgeHandlers.ConfiguratorStoragePath
             ) ?? panic("Missing configurator")
 
-        self.minter <-tokenMinter.storage.load<@ExampleHandledToken.Minter>(from: ExampleHandledToken.AdminStoragePath)
+        self.minter <-tokenMinter.storage.load<@{FlowEVMBridgeHandlerInterfaces.TokenMinter}>(from: minterStoragePath)
             ?? panic("Minter not found at provided path")
     }
 
     execute {
+        let targetType = CompositeType(vaultIdentifier)
+            ?? panic("Invalid vault identifier")
         self.configurator.createTokenHandler(
             handlerType: Type<@FlowEVMBridgeHandlers.CadenceNativeTokenHandler>(),
-            targetType: Type<@ExampleHandledToken.Vault>(),
+            targetType: targetType,
             targetEVMAddress: nil,
             minter: <-self.minter
         )