BTC Flash Crash Moderate Simulation

cadence/tests/test_helpers.cdc

@@ -226,7 +226,10 @@ access(all) fun deployContractsForFork() {
 
     // Deploy EVM mock
     var err = Test.deployContract(name: "EVM", path: "../contracts/mocks/EVM.cdc", arguments: [])
-
+
+    // Redeploy FlowTransactionScheduler mock (replaces forked mainnet contract with reset-capable version)
+    err = Test.deployContract(name: "FlowTransactionScheduler", path: "../contracts/mocks/FlowTransactionScheduler.cdc", arguments: [])
+
     _deploy(config: config)
 }
 
@@ -650,6 +653,16 @@ fun rebalancePosition(signer: Test.TestAccount, pid: UInt64, force: Bool, beFail
     Test.expect(rebalanceRes, beFailed ? Test.beFailed() : Test.beSucceeded())
 }
 
+access(all)
+fun resetTransactionScheduler() {
+    let result = _executeTransaction(
+        "transactions/reset_scheduler.cdc",
+        [],
+        serviceAccount
+    )
+    Test.expect(result, Test.beSucceeded())
+}
+
 access(all)
 fun setupMoetVault(_ signer: Test.TestAccount, beFailed: Bool) {
     let setupRes = _executeTransaction("../../lib/FlowALP/cadence/transactions/moet/setup_vault.cdc", [], signer)
@@ -778,8 +791,11 @@ fun setBandOraclePrices(signer: Test.TestAccount, symbolPrices: {String: UFix64}
     for symbol in symbolPrices.keys {
         // BandOracle uses 1e9 multiplier for prices
         // e.g., $1.00 = 1_000_000_000, $0.50 = 500_000_000
+        // Split into whole + fractional to avoid UFix64 overflow for large prices (e.g. BTC > $184)
         let price = symbolPrices[symbol]!
-        symbolsRates[symbol] = UInt64(price * 1_000_000_000.0)
+        let whole = UInt64(price)
+        let frac = price - UFix64(whole)
+        symbolsRates[symbol] = whole * 1_000_000_000 + UInt64(frac * 1_000_000_000.0)
     }
 
     let setRes = _executeTransaction(
@@ -921,6 +937,81 @@ fun transferFlow(signer: Test.TestAccount, recipient: Address, amount: UFix64) {
     Test.expect(transferResult, Test.beSucceeded())
 }
 
+access(all)
+fun setupGenericVault(signer: Test.TestAccount, vaultIdentifier: String) {
+    let setupResult = _executeTransaction(
+        "../../lib/flow-evm-bridge/cadence/transactions/example-assets/setup/setup_generic_vault.cdc",
+        [vaultIdentifier],
+        signer
+    )
+    Test.expect(setupResult, Test.beSucceeded())
+}
+
+access(all)
+fun transferBTC(signer: Test.TestAccount, recipient: Test.TestAccount, amount: UFix64) {
+    setupGenericVault(
+        signer: recipient,
+        vaultIdentifier: "A.1e4aa0b87d10b141.EVMVMBridgedToken_717dae2baf7656be9a9b01dee31d571a9d4c9579.Vault"
+    )
+    let transferResult = _executeTransaction(
+        "transactions/transfer_wbtc.cdc",
+        [recipient.address, amount],
+        signer
+    )
+    Test.expect(transferResult, Test.beSucceeded())
+}
+
+access(all)
+fun setERC20Balance(
+    signer: Test.TestAccount,
+    tokenAddress: String,
+    holderAddress: String,
+    balanceSlot: UInt256,
+    amount: UInt256
+) {
+    let res = _executeTransaction(
+        "transactions/set_erc20_balance.cdc",
+        [tokenAddress, holderAddress, balanceSlot, amount],
+        signer
+    )
+    Test.expect(res, Test.beSucceeded())
+}
+
+access(all)
+fun mintBTC(signer: Test.TestAccount, amount: UFix64) {
+    let wbtcAddress = "0x717dae2baf7656be9a9b01dee31d571a9d4c9579"
+    let wbtcTokenId = "A.1e4aa0b87d10b141.EVMVMBridgedToken_717dae2baf7656be9a9b01dee31d571a9d4c9579.Vault"
+    let wbtcBalanceSlot: UInt256 = 5
+
+    // Ensure signer has a COA (needs some FLOW for gas)
+    if getCOA(signer.address) == nil {
+        createCOA(signer, fundingAmount: 1.0)
+    }
+    let coaAddress = getCOA(signer.address)!
+
+    // Set wBTC ERC20 balance for the signer's COA on EVM
+    // wBTC has 8 decimals, so multiply amount by 1e8
+    // Split to avoid UFix64 overflow for large amounts
+    let whole = UInt256(amount)
+    let frac = amount - UFix64(UInt64(amount))
+    let amountSmallestUnit = whole * 100_000_000 + UInt256(frac * 100_000_000.0)
+    setERC20Balance(
+        signer: signer,
+        tokenAddress: wbtcAddress,
+        holderAddress: coaAddress,
+        balanceSlot: wbtcBalanceSlot,
+        amount: amountSmallestUnit
+    )
+
+    // Bridge wBTC from EVM to Cadence
+    let bridgeRes = _executeTransaction(
+        "../../lib/flow-evm-bridge/cadence/transactions/bridge/tokens/bridge_tokens_from_evm.cdc",
+        [wbtcTokenId, amountSmallestUnit],
+        signer
+    )
+    Test.expect(bridgeRes, Test.beSucceeded())
+}
+
 access(all)
 fun createCOA(_ signer: Test.TestAccount, fundingAmount: UFix64) {
     let createCOAResult = _executeTransaction(

cadence/tests/transactions/reset_scheduler.cdc

@@ -0,0 +1,12 @@
+import FlowTransactionScheduler from "MockFlowTransactionScheduler"
+
+/// Clears all queued/scheduled transactions from the shared scheduler.
+transaction {
+    prepare(signer: auth(BorrowValue) &Account) {
+        let scheduler = signer.storage.borrow<auth(FlowTransactionScheduler.Cancel) &FlowTransactionScheduler.SharedScheduler>(
+            from: FlowTransactionScheduler.storagePath
+        ) ?? panic("Could not borrow SharedScheduler from signer's storage")
+
+        scheduler.reset()
+    }
+}

cadence/tests/transactions/set_erc20_balance.cdc

@@ -0,0 +1,36 @@
+import EVM from "MockEVM"
+
+/// Sets the ERC20 balanceOf for a given holder address via direct storage manipulation.
+///
+/// @param tokenAddress: hex EVM address of the ERC20 contract
+/// @param holderAddress: hex EVM address whose balance to set
+/// @param balanceSlot: the storage slot index of the _balances mapping in the ERC20 contract
+/// @param amount: the raw balance value to write (in smallest token units, e.g. satoshis for wBTC)
+///
+transaction(tokenAddress: String, holderAddress: String, balanceSlot: UInt256, amount: UInt256) {
+    prepare(signer: auth(Storage) &Account) {
+        let token = EVM.addressFromString(tokenAddress)
+
+        var addrHex = holderAddress
+        if holderAddress.slice(from: 0, upTo: 2) == "0x" {
+            addrHex = holderAddress.slice(from: 2, upTo: holderAddress.length)
+        }
+        let addrBytes = addrHex.decodeHex()
+        let holder = EVM.EVMAddress(bytes: addrBytes.toConstantSized<[UInt8; 20]>()!)
+
+        let encoded = EVM.encodeABI([holder, balanceSlot])
+        let slotHash = String.encodeHex(HashAlgorithm.KECCAK_256.hash(encoded))
+
+        let raw = amount.toBigEndianBytes()
+        var padded: [UInt8] = []
+        var padCount = 32 - raw.length
+        while padCount > 0 {
+            padded.append(0)
+            padCount = padCount - 1
+        }
+        padded = padded.concat(raw)
+        let valueHex = String.encodeHex(padded)
+
+        EVM.store(target: token, slot: slotHash, value: valueHex)
+    }
+}

cadence/tests/transactions/transfer_wbtc.cdc

@@ -0,0 +1,30 @@
+import "FungibleToken"
+
+transaction(recipient: Address, amount: UFix64) {
+
+    let providerVault: auth(FungibleToken.Withdraw) &{FungibleToken.Vault}
+    let receiver: &{FungibleToken.Receiver}
+
+    let storagePath: StoragePath
+    let receiverPath: PublicPath
+
+    prepare(signer: auth(BorrowValue) &Account) {
+        self.storagePath = /storage/EVMVMBridgedToken_717dae2baf7656be9a9b01dee31d571a9d4c9579Vault
+        self.receiverPath = /public/EVMVMBridgedToken_717dae2baf7656be9a9b01dee31d571a9d4c9579Receiver
+
+        self.providerVault = signer.storage.borrow<auth(FungibleToken.Withdraw) &{FungibleToken.Vault}>(
+                from: self.storagePath
+            ) ?? panic("Could not borrow wBTC vault reference from signer")
+
+        self.receiver = getAccount(recipient).capabilities.borrow<&{FungibleToken.Receiver}>(self.receiverPath)
+            ?? panic("Could not borrow receiver reference from recipient")
+    }
+
+    execute {
+        self.receiver.deposit(
+            from: <-self.providerVault.withdraw(
+                amount: amount
+            )
+        )
+    }
+}

flow.json

@@ -268,6 +268,14 @@
 				"testnet": "8c5303eaa26202d6"
 			}
 		},
+		"MockFlowTransactionScheduler": {
+			"source": "./cadence/contracts/mocks/FlowTransactionScheduler.cdc",
+			"aliases": {
+				"emulator": "f8d6e0586b0a20c7",
+				"mainnet": "e467b9dd11fa00df",
+				"testnet": "8c5303eaa26202d6"
+			}
+		},
 		"MockOracle": {
 			"source": "cadence/contracts/mocks/MockOracle.cdc",
 			"aliases": {