[EVM] Add bridging interface to EVM contract

cmd/util/ledger/migrations/change_contract_code_migration.go

@@ -326,7 +326,11 @@ func SystemContractChanges(chainID flow.ChainID) []SystemContractChange {
 		// EVM related contracts
 		NewSystemContractChange(
 			systemContracts.EVMContract,
-			evm.ContractCode(systemContracts.FlowToken.Address),
+			evm.ContractCode(
+				systemContracts.NonFungibleToken.Address,
+				systemContracts.FungibleToken.Address,
+				systemContracts.FlowToken.Address,
+			),
 		),
 	}
 }

fvm/bootstrap.go

@@ -392,7 +392,7 @@ func (b *bootstrapExecutor) Execute() error {
 	b.setStakingAllowlist(service, b.identities.NodeIDs())
 
 	// sets up the EVM environment
-	b.setupEVM(service, fungibleToken, flowToken)
+	b.setupEVM(service, nonFungibleToken, fungibleToken, flowToken)
 
 	return nil
 }
@@ -806,7 +806,7 @@ func (b *bootstrapExecutor) setStakingAllowlist(
 	panicOnMetaInvokeErrf("failed to set staking allow-list: %s", txError, err)
 }
 
-func (b *bootstrapExecutor) setupEVM(serviceAddress, fungibleTokenAddress, flowTokenAddress flow.Address) {
+func (b *bootstrapExecutor) setupEVM(serviceAddress, nonFungibleTokenAddress, fungibleTokenAddress, flowTokenAddress flow.Address) {
 	if b.setupEVMEnabled {
 		// account for storage
 		// we dont need to deploy anything to this account, but it needs to exist
@@ -817,7 +817,7 @@ func (b *bootstrapExecutor) setupEVM(serviceAddress, fungibleTokenAddress, flowT
 		// deploy the EVM contract to the service account
 		tx := blueprints.DeployContractTransaction(
 			serviceAddress,
-			stdlib.ContractCode(flowTokenAddress),
+			stdlib.ContractCode(nonFungibleTokenAddress, fungibleTokenAddress, flowTokenAddress),
 			stdlib.ContractName,
 		)
 		// WithEVMEnabled should only be used after we create an account for storage

fvm/evm/stdlib/contract.cdc

@@ -1,4 +1,6 @@
 import Crypto
+import "NonFungibleToken"
+import "FungibleToken"
 import "FlowToken"
 
 access(all)
@@ -288,6 +290,59 @@ contract EVM {
                 value: value.attoflow
             ) as! Result
         }
+
+        /// Bridges the given NFT to the EVM environment, requiring a Provider from which to withdraw a fee to fulfill
+        /// the bridge request
+        access(all)
+        fun depositNFT(
+            nft: @NonFungibleToken.NFT,
+            feeProvider: &{FungibleToken.Provider}
+        ) {
+            EVM.borrowBridgeAccessor().depositNFT(nft: <-nft, to: self.address(), feeProvider: feeProvider)
+        }
+
+        /// Bridges the given NFT from the EVM environment, requiring a Provider from which to withdraw a fee to fulfill
+        /// the bridge request. Note: the caller should own the requested NFT in EVM
+        access(all)
+        fun withdrawNFT(
+            type: Type,
+            id: UInt256,
+            feeProvider: &{FungibleToken.Provider}
+        ): @NonFungibleToken.NFT {
+            return <- EVM.borrowBridgeAccessor().withdrawNFT(
+                caller: &self as &CadenceOwnedAccount,
+                type: type,
+                id: id,
+                feeProvider: feeProvider
+            )
+        }
+
+        /// Bridges the given Vault to the EVM environment, requiring a Provider from which to withdraw a fee to fulfill
+        /// the bridge request
+        access(all)
+        fun depositTokens(
+            vault: @FungibleToken.Vault,
+            feeProvider: &{FungibleToken.Provider}
+        ) {
+            EVM.borrowBridgeAccessor().depositTokens(vault: <-vault, to: self.address(), feeProvider: feeProvider)
+        }
+
+        /// Bridges the given fungible tokens from the EVM environment, requiring a Provider from which to withdraw a
+        /// fee to fulfill the bridge request. Note: the caller should own the requested tokens & sufficient balance of
+        /// requested tokens in EVM
+        access(all)
+        fun withdrawTokens(
+            type: Type,
+            amount: UInt256,
+            feeProvider: &{FungibleToken.Provider}
+        ): @FungibleToken.Vault {
+            return <- EVM.borrowBridgeAccessor().withdrawTokens(
+                caller: &self as &CadenceOwnedAccount,
+                type: type,
+                amount: amount,
+                feeProvider: feeProvider
+            )
+        }
     }
 
     /// Creates a new cadence owned account
@@ -488,4 +543,59 @@ contract EVM {
     fun getLatestBlock(): EVMBlock {
         return InternalEVM.getLatestBlock() as! EVMBlock
     }
+
+    /// Interface for a resource which acts as an entrypoint to the VM bridge
+    access(all)
+    resource interface BridgeAccessor {
+
+        /// Endpoint enabling the bridging of an NFT to EVM
+        access(all)
+        fun depositNFT(
+            nft: @NonFungibleToken.NFT,
+            to: EVMAddress,
+            feeProvider: &{FungibleToken.Provider}
+        )
+
+        /// Endpoint enabling the bridging of an NFT from EVM
+        access(all)
+        fun withdrawNFT(
+            caller: &CadenceOwnedAccount,
+            type: Type,
+            id: UInt256,
+            feeProvider: &{FungibleToken.Provider}
+        ): @NonFungibleToken.NFT
+
+        /// Endpoint enabling the bridging of a fungible token vault to EVM
+        access(all)
+        fun depositTokens(
+            vault: @FungibleToken.Vault,
+            to: EVMAddress,
+            feeProvider: &{FungibleToken.Provider}
+        )
+
+        /// Endpoint enabling the bridging of fungible tokens from EVM
+        access(all)
+        fun withdrawTokens(
+            caller: &CadenceOwnedAccount,
+            type: Type,
+            amount: UInt256,
+            feeProvider: &{FungibleToken.Provider}
+        ): @FungibleToken.Vault
+    }
+
+    /// Interface which captures a Capability to the bridge Accessor, saving it within the BridgeRouter resource
+    access(all)
+    resource interface BridgeRouter {
+
+        /// Returns a reference to the BridgeAccessor designated for internal bridge requests
+        access(all) view fun borrowBridgeAccessor(): &{BridgeAccessor}
+    }
+
+    /// Returns a reference to the BridgeAccessor designated for internal bridge requests
+    access(self)
+    view fun borrowBridgeAccessor(): &{BridgeAccessor} {
+        return self.account.borrow<&{BridgeRouter}>(from: /storage/evmBridgeRouter)
+            ?.borrowBridgeAccessor()
+            ?? panic("Could not borrow reference to the EVM bridge")
+    }
 }

fvm/evm/stdlib/contract.go

@@ -27,13 +27,24 @@ import (
 //go:embed contract.cdc
 var contractCode string
 
-var flowTokenImportPattern = regexp.MustCompile(`(?m)^import "FlowToken"\n`)
+var nftImportPattern = regexp.MustCompile(`(?m)^import "NonFungibleToken"`)
+var fungibleTokenImportPattern = regexp.MustCompile(`(?m)^import "FungibleToken"`)
+var flowTokenImportPattern = regexp.MustCompile(`(?m)^import "FlowToken"`)
 
-func ContractCode(flowTokenAddress flow.Address) []byte {
-	return []byte(flowTokenImportPattern.ReplaceAllString(
+func ContractCode(nonFungibleTokenAddress, fungibleTokenAddress, flowTokenAddress flow.Address) []byte {
+	contractCode = nftImportPattern.ReplaceAllString(
+		contractCode,
+		fmt.Sprintf("import NonFungibleToken from %s", nonFungibleTokenAddress.HexWithPrefix()),
+	)
+	contractCode = fungibleTokenImportPattern.ReplaceAllString(
+		contractCode,
+		fmt.Sprintf("import FungibleToken from %s", fungibleTokenAddress.HexWithPrefix()),
+	)
+	contractCode = flowTokenImportPattern.ReplaceAllString(
 		contractCode,
 		fmt.Sprintf("import FlowToken from %s", flowTokenAddress.HexWithPrefix()),
-	))
+	)
+	return []byte(contractCode)
 }
 
 const ContractName = "EVM"

fvm/evm/stdlib/contract_test.go

@@ -223,7 +223,7 @@ func deployContracts(
 		},
 		{
 			name: stdlib.ContractName,
-			code: stdlib.ContractCode(contractsAddress),
+			code: stdlib.ContractCode(contractsAddress, contractsAddress, contractsAddress),
 		},
 	}
 

fvm/fvm_test.go

@@ -3065,6 +3065,7 @@ func TestEVM(t *testing.T) {
 		withBootstrapProcedureOptions(fvm.WithSetupEVMEnabled(true)).
 		withContextOptions(
 			fvm.WithEVMEnabled(true),
+			fvm.WithChain(flow.Emulator.Chain()),
 			fvm.WithCadenceLogging(true),
 		).
 		run(func(
@@ -3226,6 +3227,7 @@ func TestEVM(t *testing.T) {
 			// so we have to use emulator here so that the EVM storage contract is deployed
 			// to the 5th address
 			fvm.WithChain(flow.Emulator.Chain()),
+			fvm.WithEVMEnabled(true),
 		).
 		run(func(
 			t *testing.T,