Merge branch 'main' into nialexsan/erc4626-fixes-0122

Author: nialexsan

.github/workflows/cadence_tests.yml

@@ -19,7 +19,7 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-go-
       - name: Install Flow CLI
-        run: sh -ci "$(curl -fsSL https://raw.githubusercontent.com/onflow/flow-cli/master/install.sh)" -- v2.11.1
+        run: sh -ci "$(curl -fsSL https://raw.githubusercontent.com/onflow/flow-cli/master/install.sh)" -- v2.13.4
       - name: Flow CLI Version
         run: flow version
       - name: Update PATH

.gitignore

@@ -9,3 +9,4 @@ out/
 imports
 coverage.lcov
 coverage.json
+lcov.info

cadence/contracts/connectors/SwapConnectors.cdc

@@ -251,6 +251,11 @@ access(all) contract SwapConnectors {
     /// A DeFiActions connector that deposits the resulting post-conversion currency of a token swap to an inner
     /// DeFiActions Sink, sourcing funds from a deposited Vault of a pre-set Type.
     ///
+    /// NOTE: If residual tokens remain after depositing to the inner sink, swapBack() is called on the swapper to
+    ///     return them to the original vault. One-way swappers (e.g., ERC4626SwapConnectors.Swapper) that do not
+    ///     support swapBack() can still be used safely if the inner sink always consumes all swapped tokens (i.e.,
+    ///     has sufficient capacity). If residuals occur with a one-way swapper, the transaction will revert.
+    ///
     access(all) struct SwapSink : DeFiActions.Sink {
         access(self) let swapper: {DeFiActions.Swapper}
         access(self) let sink: {DeFiActions.Sink}

cadence/contracts/connectors/evm/ERC4626SinkConnectors.cdc

@@ -3,6 +3,7 @@ import "FungibleToken"
 import "EVM"
 import "FlowEVMBridgeConfig"
 import "FlowEVMBridgeUtils"
+import "FlowToken"
 import "DeFiActions"
 import "EVMTokenConnectors"
 import "ERC4626Utils"
@@ -46,10 +47,20 @@ access(all) contract ERC4626SinkConnectors {
                 "Provided asset \(asset.identifier) is not a Vault type"
                 coa.check():
                 "Provided COA Capability is invalid - need Capability<&EVM.CadenceOwnedAccount>"
+
+                feeSource.getSourceType() == Type<@FlowToken.Vault>():
+                "Invalid feeSource - given Source must provide FlowToken Vault, but provides \(feeSource.getSourceType().identifier)"
             }
             self.asset = asset
             self.assetEVMAddress = FlowEVMBridgeConfig.getEVMAddressAssociated(with: asset)
                 ?? panic("Provided asset \(asset.identifier) is not associated with ERC20 - ensure the type & ERC20 contracts are associated via the VM bridge")
+            
+            let actualUnderlyingAddress = ERC4626Utils.underlyingAssetEVMAddress(vault: vault)
+            assert(
+                actualUnderlyingAddress?.equals(self.assetEVMAddress) ?? false,
+                message: "Provided asset \(asset.identifier) does not underly ERC4626 vault \(vault.toString()) - found \(actualUnderlyingAddress?.toString() ?? "nil") but expected \(self.assetEVMAddress.toString())"
+            )
+            
             self.vault = vault
             self.coa = coa
             self.tokenSink = EVMTokenConnectors.Sink(
@@ -100,16 +111,21 @@ access(all) contract ERC4626SinkConnectors {
             // TODO: pass from through and skip the intermediary withdrawal
             let deposit <- from.withdraw(amount: amount)
             self.tokenSink.depositCapacity(from: &deposit as auth(FungibleToken.Withdraw) &{FungibleToken.Vault})
-            if deposit.balance == amount {
-                // nothing was deposited to the EVMTokenConnectors Sink
-                Burner.burn(<-deposit)
+
+            let remainder = deposit.balance
+
+            if remainder == amount {
+                // 0 deposited -> return everything, stop
+                from.deposit(from: <-deposit)
                 return
-            } else if deposit.balance > 0.0 {
-                // update deposit amount & deposit the residual
-                amount = amount - deposit.balance
+            }
+
+            if remainder > 0.0 {
+                // partial deposited -> return remainder
+                amount = amount - remainder
                 from.deposit(from: <-deposit)
             } else {
-                // nothing left - burn & execute vault's burnCallback()
+                // fully deposited -> clean up empty vault
                 Burner.burn(<-deposit)
             }
 

cadence/contracts/connectors/evm/ERC4626SwapConnectors.cdc

@@ -3,6 +3,7 @@ import "FungibleToken"
 import "EVM"
 import "FlowEVMBridgeConfig"
 import "FlowEVMBridgeUtils"
+import "FlowToken"
 import "DeFiActions"
 import "DeFiActionsUtils"
 import "ERC4626SinkConnectors"
@@ -28,9 +29,10 @@ access(all) contract ERC4626SwapConnectors {
     /// for liquidity to flow between Cadnece & EVM. These "swaps" are performed by depositing the input asset into the
     /// ERC4626 vault and withdrawing the resulting shares from the ERC4626 vault.
     ///
-    /// NOTE: Since ERC4626 vaults typically do not support synchronous withdrawals, this Swapper only supports the
-    ///     default inType -> outType path via swap() and reverts on swapBack() since the withdrawal cannot be returned
-    ///     synchronously.
+    /// NOTE: Since ERC4626 vaults typically do not support synchronous withdrawals, this is a one-way swapper that
+    ///     only supports the default inType -> outType path via swap() and reverts on swapBack(). When used with
+    ///     SwapConnectors.SwapSink, ensure the inner sink always consumes all swapped shares (has sufficient capacity).
+    ///     If residuals remain, swapBack() will be called and the transaction will revert.
     ///
     access(all) struct Swapper : DeFiActions.Swapper {
         /// The asset type serving as the price basis in the ERC4626 vault
@@ -60,10 +62,20 @@ access(all) contract ERC4626SwapConnectors {
                 "Provided asset \(asset.identifier) is not a Vault type"
                 coa.check():
                 "Provided COA Capability is invalid - need Capability<&EVM.CadenceOwnedAccount>"
+
+                feeSource.getSourceType() == Type<@FlowToken.Vault>():
+                "Invalid feeSource - given Source must provide FlowToken Vault, but provides \(feeSource.getSourceType().identifier)"
             }
             self.asset = asset
             self.assetEVMAddress = FlowEVMBridgeConfig.getEVMAddressAssociated(with: asset)
                 ?? panic("Provided asset \(asset.identifier) is not associated with ERC20 - ensure the type & ERC20 contracts are associated via the VM bridge")
+            
+            let actualUnderlyingAddress = ERC4626Utils.underlyingAssetEVMAddress(vault: vault)
+            assert(
+                actualUnderlyingAddress?.equals(self.assetEVMAddress) ?? false,
+                message: "Provided asset \(asset.identifier) does not underly ERC4626 vault \(vault.toString()) - found \(actualUnderlyingAddress?.toString() ?? "nil") but expected \(self.assetEVMAddress.toString())"
+            )
+
             self.vault = vault
             self.vaultType = FlowEVMBridgeConfig.getTypeAssociated(with: vault)
                 ?? panic("Provided ERC4626 Vault \(vault.toString()) is not associated with a Cadence FungibleToken - ensure the type & ERC4626 contracts are associated via the VM bridge")
@@ -104,18 +116,53 @@ access(all) contract ERC4626SwapConnectors {
                     outAmount: 0.0
                 )
             }
-            let uintForDesired = FlowEVMBridgeUtils.convertCadenceAmountToERC20Amount(forDesired, erc20Address: self.vault)
+            
+            // Check maximum deposit capacity first
+            let maxCapacity = self.assetSink.minimumCapacity()
+            if maxCapacity > 0.0 {
+                let uintForDesired = FlowEVMBridgeUtils.convertCadenceAmountToERC20Amount(forDesired, erc20Address: self.vault)
+                if let uintRequired = ERC4626Utils.previewMint(vault: self.vault, shares: uintForDesired) {
+                    let uintMaxAllowed = FlowEVMBridgeUtils.convertCadenceAmountToERC20Amount(UFix64.max, erc20Address: self.assetEVMAddress)
 
-            if let uintRequired = ERC4626Utils.previewMint(vault: self.vault, shares: uintForDesired) {
-                let maxAvailableRequired = FlowEVMBridgeUtils.convertCadenceAmountToERC20Amount(UFix64.max, erc20Address: self.assetEVMAddress)
-                let safeUIntRequired = uintRequired < maxAvailableRequired ? uintRequired : maxAvailableRequired
-                let ufixRequired = FlowEVMBridgeUtils.convertERC20AmountToCadenceAmount(safeUIntRequired, erc20Address: self.assetEVMAddress)
-                return SwapConnectors.BasicQuote(
-                    inType: self.asset,
-                    outType: self.vaultType,
-                    inAmount: ufixRequired,
-                    outAmount: forDesired
-                )
+                    if uintRequired > uintMaxAllowed {
+                        return SwapConnectors.BasicQuote(
+                            inType: self.asset,
+                            outType: self.vaultType,
+                            inAmount: UFix64.max,
+                            outAmount: forDesired
+                        )
+                    }
+                    
+                    let ufixRequired = FlowEVMBridgeUtils.convertERC20AmountToCadenceAmount(uintRequired, erc20Address: self.assetEVMAddress)
+                    
+                    // Cap input to maxCapacity and recalculate output if needed
+                    if ufixRequired > maxCapacity {
+                        // Required assets exceed capacity - cap at maxCapacity and calculate achievable shares
+                        let uintMaxCapacity = FlowEVMBridgeUtils.convertCadenceAmountToERC20Amount(maxCapacity, erc20Address: self.assetEVMAddress)
+                        if let uintActualShares = ERC4626Utils.previewDeposit(vault: self.vault, assets: uintMaxCapacity) {
+                            let ufixActualShares = FlowEVMBridgeUtils.convertERC20AmountToCadenceAmount(uintActualShares, erc20Address: self.vault)
+                            return SwapConnectors.BasicQuote(
+                                inType: self.asset,
+                                outType: self.vaultType,
+                                inAmount: maxCapacity,
+                                outAmount: ufixActualShares
+                            )
+                        }
+                        return SwapConnectors.BasicQuote(
+                            inType: self.asset,
+                            outType: self.vaultType,
+                            inAmount: 0.0,
+                            outAmount: 0.0
+                        )
+                    }
+                    
+                    return SwapConnectors.BasicQuote(
+                        inType: self.asset,
+                        outType: self.vaultType,
+                        inAmount: ufixRequired,
+                        outAmount: forDesired
+                    )
+                }
             }
             return SwapConnectors.BasicQuote(
                 inType: self.asset,
@@ -172,21 +219,62 @@ access(all) contract ERC4626SwapConnectors {
 
             // assign or get the quote for the swap
             let _quote = quote ?? self.quoteOut(forProvided: inVault.balance, reverse: false)
+            let outAmount = _quote.outAmount
+
+            assert(_quote.inType == self.inType(), message: "Quote inType mismatch")
+            assert(_quote.outType == self.outType(), message: "Quote outType mismatch")
+            assert(_quote.inAmount > 0.0, message: "Invalid quote: inAmount must be > 0")
+            assert(outAmount > 0.0, message: "Invalid quote: outAmount must be > 0")
+
+            // --- Slippage protection: don't allow spending more than quoted ---
+            let beforeInBalance = inVault.balance
+            assert(
+                beforeInBalance <= _quote.inAmount,
+                message: "Swap input (\(beforeInBalance)) exceeds quote.inAmount (\(_quote.inAmount)). Provide an updated quote or reduce inVault balance."
+            )
 
-            // get the before available shares
+            // Track shares available before/after to determine received shares
             let beforeAvailable = self.shareSource.minimumAvailable()
 
-            // deposit the inVault into the asset sink
+            // Deposit the inVault into the asset sink (should consume all of it)
             self.assetSink.depositCapacity(from: &inVault as auth(FungibleToken.Withdraw) &{FungibleToken.Vault})
+
+            let remainder = inVault.balance
+            let consumedIn = beforeInBalance - remainder
+
+            // We expect full consumption in this connector's semantics.
+            // If this ever becomes "partial fill" in the future, this check + price check below
+            // ensures it still can't be worse than quoted.
+            assert(
+                consumedIn > 0.0,
+                message: "Asset sink did not consume any input."
+            )
+            assert(remainder == 0.0, message: "Asset sink did not consume full input; remainder: \(remainder.toString()). Adjust inVault balance.") 
+
             Burner.burn(<-inVault)
 
             // get the after available shares
             let afterAvailable = self.shareSource.minimumAvailable()
             assert(afterAvailable > beforeAvailable, message: "Expected ERC4626 Vault \(self.vault.toString()) to have more shares after depositing")
 
             // withdraw the available difference in shares
-            let availableDiff = afterAvailable - beforeAvailable
-            let sharesVault <- self.shareSource.withdrawAvailable(maxAmount: availableDiff)
+            let receivedShares = afterAvailable - beforeAvailable
+
+            // --- Slippage protection: ensure minimum out ---
+            assert(
+                receivedShares >= outAmount,
+                message: "Slippage: received \(receivedShares) < quote.outAmount (\(outAmount))."
+            )
+
+            let sharesVault <- self.shareSource.withdrawAvailable(maxAmount: receivedShares)
+
+            // Extra safety: ensure the vault we’re returning matches the computed delta
+            // (withdrawAvailable could theoretically return less if liquidity changed)
+            assert(
+                sharesVault.balance >= outAmount,
+                message: "Slippage: withdrawn shares \(sharesVault.balance) < outAmount (\(outAmount))."
+            )
+
             return <- sharesVault
         }
         /// Performs a swap taking a Vault of type outVault, outputting a resulting inVault. Implementations may choose

cadence/contracts/connectors/evm/EVMTokenConnectors.cdc

@@ -209,7 +209,9 @@ access(all) contract EVMTokenConnectors {
             return DeFiActions.ComponentInfo(
                 type: self.getType(),
                 id: self.id(),
-                innerComponents: []
+                innerComponents: [
+                    self.feeSource.getComponentInfo()
+                ]
             )
         }
         /// Sets the UniqueIdentifier of this component to the provided UniqueIdentifier, used in extending a stack to
@@ -291,7 +293,13 @@ access(all) contract EVMTokenConnectors {
             if feeVault.balance > 0.0 {
                 self.feeSource.depositCapacity(from: &feeVault as auth(FungibleToken.Withdraw) &{FungibleToken.Vault})
             }
+            // feeSource should not enforce a deposit capacity limit, as it is only a vault backing a sink.
+            // Assert here to catch unexpected partial deposits.
+            assert(
+                feeVault.balance == 0.0,
+                message: "Fee sink failed to accept full balance; feeVault still contains funds"
+            )
             Burner.burn(<-feeVault)
         }
     }
-}
+}

cadence/contracts/connectors/evm/UniswapV3SwapConnectors.cdc

@@ -19,30 +19,6 @@ import "EVMAbiHelpers"
 /// Supports single-hop and multi-hop swaps using exactInput / exactInputSingle and Quoter for estimates.
 ///
 access(all) contract UniswapV3SwapConnectors {
-    // (bytes,address,uint256,uint256)
-    access(all) fun encodeTuple_bytes_addr_u256_u256(
-        path: [UInt8],
-        recipient: EVM.EVMAddress,
-        amountOne: UInt256,
-        amountTwo: UInt256
-    ): [UInt8] {
-        let tupleHeadSize = 32 * 4
-
-        var head: [[UInt8]] = []
-        var tail: [[UInt8]] = []
-
-        // 1) bytes path (dynamic) -> pointer to tail, relative to start of this tuple blob
-        head.append(EVMAbiHelpers.abiWord(UInt256(tupleHeadSize)))
-        tail.append(EVMAbiHelpers.abiDynamicBytes(path))
-
-        head.append(EVMAbiHelpers.abiAddress(recipient))
-
-        head.append(EVMAbiHelpers.abiUInt256(amountOne))
-
-        head.append(EVMAbiHelpers.abiUInt256(amountTwo))
-
-        return EVMAbiHelpers.concat(head).concat(EVMAbiHelpers.concat(tail))
-    }
 
     /// Convert an ERC20 `UInt256` amount into a Cadence `UFix64` **by rounding down** to the
     /// maximum `UFix64` precision (8 decimal places).
@@ -88,6 +64,27 @@ access(all) contract UniswapV3SwapConnectors {
         return FlowEVMBridgeUtils.uint256ToUFix64(value: padded, decimals: decimals)
     }
 
+    /// ExactInputSingleParams facilitates the ABI encoding/decoding of the
+    /// Solidity tuple expected in `ISwapRouter.exactInput` function.
+    access(all) struct ExactInputSingleParams {
+        access(all) let path: EVM.EVMBytes
+        access(all) let recipient: EVM.EVMAddress
+        access(all) let amountIn: UInt256
+        access(all) let amountOutMinimum: UInt256
+
+        init(
+            path: EVM.EVMBytes,
+            recipient: EVM.EVMAddress,
+            amountIn: UInt256,
+            amountOutMinimum: UInt256
+        ) {
+            self.path = path
+            self.recipient = recipient
+            self.amountIn = amountIn
+            self.amountOutMinimum = amountOutMinimum
+        }
+    }
+
     /// Swapper
     access(all) struct Swapper: DeFiActions.Swapper {
         access(all) let routerAddress: EVM.EVMAddress
@@ -439,7 +436,7 @@ access(all) contract UniswapV3SwapConnectors {
 
             let args: [AnyStruct] = [pathBytes, amount]
 
-            let res = self._dryCall(self.quoterAddress, callSig, args, 1_000_000)
+            let res = self._dryCall(self.quoterAddress, callSig, args, 10_000_000)
             if res == nil || res!.status != EVM.Status.successful { return nil }
 
             let decoded = EVM.decodeABI(types: [Type<UInt256>()], data: res!.data)
@@ -501,9 +498,6 @@ access(all) contract UniswapV3SwapConnectors {
                 erc20Address: outToken
             )
 
-            // exactInput((bytes,address,uint256,uint256)) selector = 0xb858183f
-            let selector: [UInt8] = [0xb8, 0x58, 0x18, 0x3f]
-
             let coaRef = self.borrowCOA()!
             let recipient: EVM.EVMAddress = coaRef.address()
 
@@ -514,26 +508,23 @@ access(all) contract UniswapV3SwapConnectors {
             assert(_chkIn.length == 32,  message: "amountIn not 32 bytes")
             assert(_chkMin.length == 32, message: "amountOutMin not 32 bytes")
 
-            // 1) Build the tuple blob (you already have this)
-            let argsBlob: [UInt8] = UniswapV3SwapConnectors.encodeTuple_bytes_addr_u256_u256(
-                path: pathBytes.value,
+            let exactInputParams = UniswapV3SwapConnectors.ExactInputSingleParams(
+                path: pathBytes,
                 recipient: recipient,
-                amountOne: evmAmountIn,
-                amountTwo: minOutUint
+                amountIn: evmAmountIn,
+                amountOutMinimum: minOutUint
             )
 
-            // 2) Head for a single dynamic arg is always 32
-            let head: [UInt8] = EVMAbiHelpers.abiWord(UInt256(32))
-
-            // 3) Final calldata = selector || head || tuple
-            let calldata: [UInt8] = selector.concat(head).concat(argsBlob)
-
+            let calldata: [UInt8] = EVM.encodeABIWithSignature(
+                "exactInput((bytes,address,uint256,uint256))",
+                [exactInputParams]
+            )
 
             // Call the router with raw calldata
             let swapRes = self._callRaw(
                 to: self.routerAddress,
                 calldata: calldata,
-                gasLimit: 2_000_000,
+                gasLimit: 10_000_000,
                 value: 0
             )!
             if swapRes.status != EVM.Status.successful {