Flow

.solhint.json

@@ -2,7 +2,7 @@
   "extends": "solhint:recommended",
   "rules": {
     "max-line-length": "off",
-    "compiler-version": ["error", "=0.8.15 || ^0.8.0"],
+    "compiler-version": ["error", "=0.8.17 || ^0.8.0"],
     "no-inline-assembly": "off",
     "not-rely-on-time": "off",
     "no-empty-blocks": "off",

.vscode/settings.json

@@ -2,5 +2,6 @@
   "nixEnvSelector.suggestion": false,
   "solidity.compileUsingRemoteVersion": "v0.8.15+commit.e14f2714",
   "solidity.compileUsingLocalVersion": "v0.8.15+commit.e14f2714",
-  "nixEnvSelector.nixFile": "${workspaceRoot}/shell.nix"
+  "nixEnvSelector.nixFile": "${workspaceRoot}/shell.nix",
+  "editor.rulers": [80]
 }

contracts/array/LibUint256Array.sol

@@ -37,6 +37,54 @@ library LibUint256Array {
         return array_;
     }
 
+    function arrayFrom(
+        uint256 a_,
+        uint256 b_,
+        uint256 c_
+    ) internal pure returns (uint256[] memory) {
+        uint256[] memory array_ = new uint256[](3);
+        assembly ("memory-safe") {
+            mstore(add(array_, 0x20), a_)
+            mstore(add(array_, 0x40), b_)
+            mstore(add(array_, 0x60), c_)
+        }
+        return array_;
+    }
+
+    function arrayFrom(
+        uint256 a_,
+        uint256 b_,
+        uint256 c_,
+        uint256 d_
+    ) internal pure returns (uint256[] memory) {
+        uint256[] memory array_ = new uint256[](4);
+        assembly ("memory-safe") {
+            mstore(add(array_, 0x20), a_)
+            mstore(add(array_, 0x40), b_)
+            mstore(add(array_, 0x60), c_)
+            mstore(add(array_, 0x80), d_)
+        }
+        return array_;
+    }
+
+    function arrayFrom(
+        uint256 a_,
+        uint256 b_,
+        uint256 c_,
+        uint256 d_,
+        uint256 e_
+    ) internal pure returns (uint256[] memory) {
+        uint256[] memory array_ = new uint256[](5);
+        assembly ("memory-safe") {
+            mstore(add(array_, 0x20), a_)
+            mstore(add(array_, 0x40), b_)
+            mstore(add(array_, 0x60), c_)
+            mstore(add(array_, 0x80), d_)
+            mstore(add(array_, 0xA0), e_)
+        }
+        return array_;
+    }
+
     /// Building arrays from literal components is a common task that introduces
     /// boilerplate that is either inefficient or error prone.
     /// @param a_ The head of the new array.

contracts/debug/LibDebug.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: CAL
-pragma solidity =0.8.15;
+pragma solidity =0.8.17;
 
 import "hardhat/console.sol";
 

contracts/escrow/RedeemableERC20ClaimEscrow.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: CAL
-pragma solidity =0.8.15;
+pragma solidity =0.8.17;
 
 import {RedeemableERC20} from "../redeemableERC20/RedeemableERC20.sol";
 import {MathUpgradeable as Math} from "@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol";

contracts/escrow/SaleEscrow.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: CAL
-pragma solidity =0.8.15;
+pragma solidity =0.8.17;
 
 import "../sale/ISale.sol";
 

contracts/factory/Factory.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: CAL
-pragma solidity =0.8.15;
+pragma solidity =0.8.17;
 
 import {IFactory} from "./IFactory.sol";
 import {ReentrancyGuardUpgradeable as ReentrancyGuard} from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";

contracts/factory/FactoryCurator.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: CAL
-pragma solidity =0.8.15;
+pragma solidity =0.8.17;
 
 import "./IFactory.sol";
 import {IERC20Upgradeable as IERC20} from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";

contracts/flow/basic/Flow.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: CAL
+pragma solidity =0.8.17;
+
+import "../vm/FlowVM.sol";
+import "../libraries/LibFlow.sol";
+import {ReentrancyGuardUpgradeable as ReentrancyGuard} from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+
+struct FlowConfig {
+    // This is NOT USED by `Flow` but removing it causes the compiler to fail to
+    // compile the code with optimizations. Removing this seems to cause the EVM
+    // stack to overflow.
+    StateConfig stateConfig;
+    StateConfig[] flows;
+}
+
+contract Flow is ReentrancyGuard, FlowVM {
+    using LibVMState for VMState;
+
+    event Initialize(address sender, FlowConfig config);
+
+    /// flow index => id => time
+    mapping(SourceIndex => mapping(uint256 => uint256)) private _flows;
+
+    constructor(address vmIntegrity_) FlowVM(vmIntegrity_) {}
+
+    /// @param config_ allowed flows set at initialization.
+    function initialize(FlowConfig calldata config_) external initializer {
+        __FlowVM_init(config_.flows, LibUint256Array.arrayFrom(1, 4));
+        emit Initialize(msg.sender, config_);
+    }
+
+    function _previewFlow(VMState memory state_)
+        internal
+        view
+        returns (FlowTransfer memory)
+    {
+        StackTop stackTop_ = flowStack(state_);
+        return LibFlow.stackToFlow(state_.stackBottom, stackTop_);
+    }
+
+    function previewFlow(uint256 flow_, uint256 id_)
+        external
+        view
+        virtual
+        returns (FlowTransfer memory)
+    {
+        return _previewFlow(_loadFlowState(flow_, id_));
+    }
+
+    function flow(uint256 flow_, uint256 id_)
+        external
+        payable
+        virtual
+        nonReentrant
+        returns (FlowTransfer memory)
+    {
+        VMState memory state_ = _loadFlowState(flow_, id_);
+        FlowTransfer memory flowTransfer_ = _previewFlow(state_);
+        registerFlowTime(IdempotentFlag.wrap(state_.scratch), flow_, id_);
+        return LibFlow.flow(flowTransfer_, address(this), payable(msg.sender));
+    }
+}