update refs

Author: nialexsan

cadence/transactions/connectors/univ3-swap-connector.cdc

@@ -8,78 +8,76 @@ import "FlowEVMBridgeConfig"
 transaction() {
 
   prepare(acct: auth(Storage, Capabilities) &Account) {
-    // 1) COA capability your test published earlier
+    // COA capability: either issue from storage (owner) or use a published public cap.
     let coaCap: Capability<auth(EVM.Owner) &EVM.CadenceOwnedAccount> =
       acct.capabilities.storage.issue<auth(EVM.Owner) &EVM.CadenceOwnedAccount>(/storage/evm)
 
-    // 2) Router + Quoter + tokens from your forge deployment
+    // Router + Quoter + tokens (FLOW → USDC)
     let router = EVM.addressFromString("0xB685ab04Dfef74c135A2ed4003441fF124AFF9a0")
     let quoter = EVM.addressFromString("0xA1e0E4CCACA34a738f03cFB1EAbAb16331FA3E2c")
 
     let usdc  = EVM.addressFromString("0x5e65b6B04fbA51D95409712978Cb91E99d93aE73")
-    let wflow = EVM.addressFromString("0xd3bF53DAC106A0290B0483EcBC89d40FcC961f3e")
+    let wflow = EVM.addressFromString("0xd3bF53DAC106A0290B0483EcBC89d40FcC961f3e") // WFLOW on EVM side
 
-    // Types associated with ERC20s on Flow
-    let inType: Type = FlowEVMBridgeConfig.getTypeAssociated(with: usdc) ?? panic("invalid in type")
-    let outType = Type<@FlowToken.Vault>()
-    // If WFLOW maps to FlowToken.Vault, outType should equal Type<@FlowToken.Vault>()
+    // Vault types for in/out
+    let inType: Type = Type<@FlowToken.Vault>() // FLOW in
+    let outType: Type = FlowEVMBridgeConfig.getTypeAssociated(with: usdc) ?? panic("invalid USDC out type")
 
-    // 3) Instantiate the V3 Swapper (single hop USDC -> WFLOW @ 0.3%)
+    // Swapper: tokenPath must be [WFLOW, USDC] for FLOW → USDC
     let swapper = UniswapV3SwapConnectors.Swapper(
       routerAddress: router,
       quoterAddress: quoter,
-      tokenPath: [usdc, wflow],
+      tokenPath: [wflow, usdc],
       feePath: [3000], // 0.3%
       inVault: inType,
       outVault: outType,
       coaCapability: coaCap,
       uniqueID: nil
     )
 
-    // 4) Bring in USDC from storage for testing (use FT interfaces for dynamic types)
-    let usdcStoragePath = /storage/EVMVMBridgedToken_5e65b6b04fba51d95409712978cb91e99d93ae73Vault
-    let usdcWithdrawRef = acct.storage
-      .borrow<auth(FungibleToken.Withdraw) &{FungibleToken.Vault}>(from: usdcStoragePath)
-      ?? panic("Missing USDC vault at \(usdcStoragePath)")
-
-    let amountIn: UFix64 = 100.0
-    let vaultIn <- usdcWithdrawRef.withdraw(amount: amountIn)
+    // ---- Swap FLOW → USDC (quoteOut + swap) ----
+    // Withdraw FLOW
+    let flowStoragePath = /storage/flowTokenVault
+    let flowWithdrawRef = acct.storage
+      .borrow<auth(FungibleToken.Withdraw) &FlowToken.Vault>(from: flowStoragePath)
+      ?? panic("Missing FLOW vault at /storage/flowTokenVault")
 
-    // 5) Quote output for provided input
-    let q = swapper.quoteOut(forProvided: amountIn, reverse: false)
-    log("Quote out for provided ".concat(amountIn.toString()).concat(": ").concat(q.outAmount.toString()))
+    let flowIn: UFix64 = 100.0
+    let flowVaultIn <- flowWithdrawRef.withdraw(amount: flowIn)
 
-    // 6) Perform the swap with min-out from the quote
-    let outVault <- swapper.swap(quote: q, inVault: <-vaultIn)
-    log("Swap out received: ".concat(outVault.balance.toString()))
+    // Quote how much USDC we’ll get
+    let q = swapper.quoteOut(forProvided: flowIn, reverse: false)
+    log("Quote out for provided ".concat(flowIn.toString()).concat(" FLOW → USDC: ").concat(q.outAmount.toString()))
 
-    // Deposit result (WFLOW) — if WFLOW maps to FlowToken.Vault, deposit to that path
-    let wflowStoragePath = /storage/wflowVault
-    let wflowDepositRef = acct.storage
-      .borrow<&{FungibleToken.Vault}>(from: wflowStoragePath)
-      ?? panic("Missing WFLOW vault at /storage/wflowVault")
-    wflowDepositRef.deposit(from: <-outVault)
+    // Perform the swap
+    let usdcOut <- swapper.swap(quote: q, inVault: <-flowVaultIn)
+    log("USDC received: ".concat(usdcOut.balance.toString()))
 
-    // 7) “Exact-out” pattern:
-    //    Pre-quote the required input for desired WFLOW, withdraw exactly that, then swap.
-    let desiredWFLOW: UFix64 = 0.01
-    let qi = swapper.quoteIn(forDesired: desiredWFLOW, reverse: false)
-    let needIn: UFix64 = qi.inAmount
-    log("ExactOut desired ".concat(desiredWFLOW.toString()).concat(" WFLOW; need USDC: ").concat(needIn.toString()))
+    // Deposit USDC
+    let usdcStoragePath = /storage/EVMVMBridgedToken_5e65b6b04fba51d95409712978cb91e99d93ae73Vault
+    let usdcReceiver = acct.storage
+      .borrow<&{FungibleToken.Receiver}>(from: usdcStoragePath)
+      ?? panic("Missing USDC vault at ".concat(usdcStoragePath.toString()))
+    usdcReceiver.deposit(from: <-usdcOut)
 
-    let usdcWithdrawRef2 = acct.storage
-      .borrow<auth(FungibleToken.Withdraw) &{FungibleToken.Vault}>(from: usdcStoragePath)
-      ?? panic("Missing USDC vault at \(usdcStoragePath) (for exactOut)")
-    let maxSpend: UFix64 = 100.0
-    assert(needIn <= maxSpend, message: "Required USDC exceeds test max spend")
+    // ---- Exact-out USDC: pre-quote input FLOW, then swap ----
+    let desiredUSDC: UFix64 = 10.0
+    let qi = swapper.quoteIn(forDesired: desiredUSDC, reverse: false)
+    let needFlow: UFix64 = qi.inAmount
+    log("ExactOut want ".concat(desiredUSDC.toString()).concat(" USDC; need FLOW: ").concat(needFlow.toString()))
 
-    let needVault <- usdcWithdrawRef2.withdraw(amount: needIn)
-    let outVault2 <- swapper.swap(quote: qi, inVault: <-needVault)
-    log("ExactOut swap received WFLOW: ".concat(outVault2.balance.toString()))
+    // Withdraw required FLOW
+    let flowWithdrawRef2 = acct.storage
+      .borrow<auth(FungibleToken.Withdraw) &FlowToken.Vault>(from: flowStoragePath)
+      ?? panic("Missing FLOW vault for exact-out")
+    let flowNeedVault <- flowWithdrawRef2.withdraw(amount: needFlow)
 
-    let wflowDepositRef2 = acct.storage
-      .borrow<&{FungibleToken.Vault}>(from: wflowStoragePath)
-      ?? panic("Missing WFLOW vault for exactOut deposit")
-    wflowDepositRef2.deposit(from: <-outVault2)
+    // Swap and deposit USDC
+    let usdcOut2 <- swapper.swap(quote: qi, inVault: <-flowNeedVault)
+    log("ExactOut USDC received: ".concat(usdcOut2.balance.toString()))
+    let usdcReceiver2 = acct.storage
+      .borrow<&{FungibleToken.Receiver}>(from: usdcStoragePath)
+      ?? panic("Missing USDC vault for exact-out deposit")
+    usdcReceiver2.deposit(from: <-usdcOut2)
   }
 }

flow.json

@@ -129,6 +129,13 @@
 				"testing": "0000000000000007"
 			}
 		},
+		"UniswapV3SwapConnectors1": {
+			"source": "./lib/TidalProtocol/DeFiActions/cadence/contracts/connectors/evm/UniswapV3SwapConnectors1.cdc",
+			"aliases": {
+				"emulator": "f8d6e0586b0a20c7",
+				"testing": "0000000000000007"
+			}
+		},
 		"YieldToken": {
 			"source": "cadence/contracts/mocks/YieldToken.cdc",
 			"aliases": {
@@ -665,8 +672,9 @@
 		},
 		"testnet": {
 			"testnet-deployer": [
-				"UniswapV3SwapConnectors"
+				"UniswapV3SwapConnectors",
+				"UniswapV3SwapConnectors1"
 			]
 		}
 	}
-}
+}