Holochain Currency Exchange Architecture¶

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

/**
 * @title HolochainCurrencyExchange
 * @dev Decentralized exchange for Holochain currencies
 */
contract HolochainCurrencyExchange {

    // Structs
    struct Order {
        address maker;              // Ethereum address of maker
        bytes holochainPubKey;      // Holochain public key
        string fromCurrency;        // "zerotrustml_credits"
        string toCurrency;          // "timebank_hours"
        uint256 amount;             // Amount to swap
        uint256 rate;               // Exchange rate (scaled 1e18)
        uint256 minRate;            // Min acceptable rate (slippage)
        uint256 expiry;             // Unix timestamp expiry
        bool active;                // Order status
    }

    struct Swap {
        uint256 order1Id;           // First order ID
        uint256 order2Id;           // Second order ID
        uint256 amount1;            // Amount from order 1
        uint256 amount2;            // Amount from order 2
        uint256 executionRate;      // Final rate
        uint256 timestamp;          // When executed
        bytes[] bridgeSignatures;   // Validator signatures
    }

    // State
    uint256 public nextOrderId = 1;
    uint256 public nextSwapId = 1;

    mapping(uint256 => Order) public orders;
    mapping(bytes32 => uint256[]) public orderbook; // Currency pair => order IDs
    mapping(uint256 => Swap) public swaps;

    // Bridge validator whitelist (multisig)
    mapping(address => bool) public bridgeValidators;
    uint256 public requiredValidatorSignatures = 3;

    // Events
    event OrderPosted(
        uint256 indexed orderId,
        address indexed maker,
        string fromCurrency,
        string toCurrency,
        uint256 amount,
        uint256 rate
    );

    event OrderCancelled(uint256 indexed orderId);

    event SwapExecuted(
        uint256 indexed swapId,
        uint256 order1Id,
        uint256 order2Id,
        uint256 amount1,
        uint256 amount2,
        uint256 rate
    );

    // Modifiers
    modifier onlyBridgeValidator() {
        require(bridgeValidators[msg.sender], "Not a bridge validator");
        _;
    }

    // Constructor
    constructor(address[] memory initialValidators) {
        for (uint256 i = 0; i < initialValidators.length; i++) {
            bridgeValidators[initialValidators[i]] = true;
        }
    }

    /**
     * @dev Post a new order
     */
    function postOrder(
        bytes memory holochainPubKey,
        string memory fromCurrency,
        string memory toCurrency,
        uint256 amount,
        uint256 rate,
        uint256 minRate,
        uint256 expiryMinutes
    ) external returns (uint256) {
        require(amount > 0, "Amount must be positive");
        require(rate > 0, "Rate must be positive");
        require(minRate <= rate, "Min rate exceeds rate");

        uint256 orderId = nextOrderId++;

        orders[orderId] = Order({
            maker: msg.sender,
            holochainPubKey: holochainPubKey,
            fromCurrency: fromCurrency,
            toCurrency: toCurrency,
            amount: amount,
            rate: rate,
            minRate: minRate,
            expiry: block.timestamp + (expiryMinutes * 60),
            active: true
        });

        // Add to orderbook
        bytes32 pairKey = keccak256(abi.encodePacked(fromCurrency, toCurrency));
        orderbook[pairKey].push(orderId);

        emit OrderPosted(orderId, msg.sender, fromCurrency, toCurrency, amount, rate);

        return orderId;
    }

    /**
     * @dev Cancel an order
     */
    function cancelOrder(uint256 orderId) external {
        Order storage order = orders[orderId];
        require(order.maker == msg.sender, "Not order maker");
        require(order.active, "Order not active");

        order.active = false;

        emit OrderCancelled(orderId);
    }

    /**
     * @dev Execute atomic swap between two orders
     * @notice Only callable by bridge validators with signatures
     */
    function executeSwap(
        uint256 order1Id,
        uint256 order2Id,
        uint256 amount1,
        uint256 amount2,
        bytes[] memory bridgeSignatures
    ) external onlyBridgeValidator returns (uint256) {
        // Validate orders
        Order storage order1 = orders[order1Id];
        Order storage order2 = orders[order2Id];

        require(order1.active, "Order 1 not active");
        require(order2.active, "Order 2 not active");
        require(order1.expiry > block.timestamp, "Order 1 expired");
        require(order2.expiry > block.timestamp, "Order 2 expired");

        // Validate currency pairs match (inverse)
        require(
            keccak256(bytes(order1.fromCurrency)) == keccak256(bytes(order2.toCurrency)) &&
            keccak256(bytes(order1.toCurrency)) == keccak256(bytes(order2.fromCurrency)),
            "Currency pair mismatch"
        );

        // Validate amounts
        require(amount1 <= order1.amount, "Exceeds order 1 amount");
        require(amount2 <= order2.amount, "Exceeds order 2 amount");

        // Calculate rate
        uint256 executionRate = (amount2 * 1e18) / amount1;

        // Validate rate within slippage
        require(executionRate >= order1.minRate, "Below order 1 min rate");
        require(executionRate <= order2.rate, "Exceeds order 2 rate");

        // Validate signatures
        require(
            bridgeSignatures.length >= requiredValidatorSignatures,
            "Insufficient validator signatures"
        );
        require(
            verifyBridgeSignatures(order1Id, order2Id, amount1, amount2, bridgeSignatures),
            "Invalid signatures"
        );

        // Update orders
        order1.amount -= amount1;
        order2.amount -= amount2;

        if (order1.amount == 0) order1.active = false;
        if (order2.amount == 0) order2.active = false;

        // Record swap
        uint256 swapId = nextSwapId++;
        swaps[swapId] = Swap({
            order1Id: order1Id,
            order2Id: order2Id,
            amount1: amount1,
            amount2: amount2,
            executionRate: executionRate,
            timestamp: block.timestamp,
            bridgeSignatures: bridgeSignatures
        });

        emit SwapExecuted(swapId, order1Id, order2Id, amount1, amount2, executionRate);

        return swapId;
    }

    /**
     * @dev Verify bridge validator signatures
     */
    function verifyBridgeSignatures(
        uint256 order1Id,
        uint256 order2Id,
        uint256 amount1,
        uint256 amount2,
        bytes[] memory signatures
    ) internal view returns (bool) {
        bytes32 messageHash = keccak256(abi.encodePacked(
            order1Id,
            order2Id,
            amount1,
            amount2,
            block.chainid
        ));

        bytes32 ethSignedHash = keccak256(abi.encodePacked(
            "\x19Ethereum Signed Message:\n32",
            messageHash
        ));

        uint256 validSignatures = 0;
        address[] memory signers = new address[](signatures.length);

        for (uint256 i = 0; i < signatures.length; i++) {
            address signer = recoverSigner(ethSignedHash, signatures[i]);

            // Check signer is validator and hasn't already signed
            if (bridgeValidators[signer] && !containsAddress(signers, signer)) {
                signers[i] = signer;
                validSignatures++;
            }
        }

        return validSignatures >= requiredValidatorSignatures;
    }

    /**
     * @dev Recover signer from signature
     */
    function recoverSigner(bytes32 hash, bytes memory signature)
        internal
        pure
        returns (address)
    {
        require(signature.length == 65, "Invalid signature length");

        bytes32 r;
        bytes32 s;
        uint8 v;

        assembly {
            r := mload(add(signature, 32))
            s := mload(add(signature, 64))
            v := byte(0, mload(add(signature, 96)))
        }

        return ecrecover(hash, v, r, s);
    }

    /**
     * @dev Check if array contains address
     */
    function containsAddress(address[] memory array, address addr)
        internal
        pure
        returns (bool)
    {
        for (uint256 i = 0; i < array.length; i++) {
            if (array[i] == addr) return true;
        }
        return false;
    }

    /**
     * @dev Get orderbook for currency pair
     */
    function getOrderbook(string memory fromCurrency, string memory toCurrency)
        external
        view
        returns (uint256[] memory)
    {
        bytes32 pairKey = keccak256(abi.encodePacked(fromCurrency, toCurrency));
        return orderbook[pairKey];
    }

    /**
     * @dev Get active orders for currency pair
     */
    function getActiveOrders(string memory fromCurrency, string memory toCurrency)
        external
        view
        returns (Order[] memory)
    {
        bytes32 pairKey = keccak256(abi.encodePacked(fromCurrency, toCurrency));
        uint256[] memory orderIds = orderbook[pairKey];

        // Count active orders
        uint256 activeCount = 0;
        for (uint256 i = 0; i < orderIds.length; i++) {
            if (orders[orderIds[i]].active && orders[orderIds[i]].expiry > block.timestamp) {
                activeCount++;
            }
        }

        // Build active orders array
        Order[] memory activeOrders = new Order[](activeCount);
        uint256 index = 0;
        for (uint256 i = 0; i < orderIds.length; i++) {
            Order memory order = orders[orderIds[i]];
            if (order.active && order.expiry > block.timestamp) {
                activeOrders[index] = order;
                index++;
            }
        }

        return activeOrders;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

/**
 * @title HolochainCurrencyPool
 * @dev Liquidity pool for Holochain currency pairs
 */
contract HolochainCurrencyPool {

    struct Pool {
        string currency1;
        string currency2;
        uint256 reserve1;       // Virtual reserves (not actual tokens)
        uint256 reserve2;
        uint256 totalShares;
        mapping(address => uint256) shares;
    }

    mapping(bytes32 => Pool) public pools;

    event PoolCreated(string currency1, string currency2);
    event LiquidityAdded(string currency1, string currency2, uint256 amount1, uint256 amount2);
    event LiquidityRemoved(string currency1, string currency2, uint256 amount1, uint256 amount2);
    event Swap(string fromCurrency, string toCurrency, uint256 amountIn, uint256 amountOut);

    /**
     * @dev Create liquidity pool for currency pair
     */
    function createPool(string memory currency1, string memory currency2) external {
        bytes32 poolKey = getPoolKey(currency1, currency2);
        require(pools[poolKey].totalShares == 0, "Pool exists");

        Pool storage pool = pools[poolKey];
        pool.currency1 = currency1;
        pool.currency2 = currency2;

        emit PoolCreated(currency1, currency2);
    }

    /**
     * @dev Add liquidity (called by bridge validators after Holochain escrow)
     */
    function addLiquidity(
        string memory currency1,
        string memory currency2,
        uint256 amount1,
        uint256 amount2,
        address provider
    ) external returns (uint256 shares) {
        bytes32 poolKey = getPoolKey(currency1, currency2);
        Pool storage pool = pools[poolKey];

        if (pool.totalShares == 0) {
            // First liquidity provider
            shares = sqrt(amount1 * amount2);
        } else {
            // Subsequent providers
            shares = min(
                (amount1 * pool.totalShares) / pool.reserve1,
                (amount2 * pool.totalShares) / pool.reserve2
            );
        }

        require(shares > 0, "Insufficient liquidity");

        pool.reserve1 += amount1;
        pool.reserve2 += amount2;
        pool.totalShares += shares;
        pool.shares[provider] += shares;

        emit LiquidityAdded(currency1, currency2, amount1, amount2);
    }

    /**
     * @dev Calculate output amount for swap (constant product formula)
     */
    function getAmountOut(
        string memory fromCurrency,
        string memory toCurrency,
        uint256 amountIn
    ) public view returns (uint256) {
        bytes32 poolKey = getPoolKey(fromCurrency, toCurrency);
        Pool storage pool = pools[poolKey];

        bool isForward = keccak256(bytes(pool.currency1)) == keccak256(bytes(fromCurrency));

        uint256 reserveIn = isForward ? pool.reserve1 : pool.reserve2;
        uint256 reserveOut = isForward ? pool.reserve2 : pool.reserve1;

        require(amountIn > 0, "Amount must be positive");
        require(reserveIn > 0 && reserveOut > 0, "Insufficient liquidity");

        // Constant product formula with 0.3% fee
        uint256 amountInWithFee = amountIn * 997;
        uint256 numerator = amountInWithFee * reserveOut;
        uint256 denominator = (reserveIn * 1000) + amountInWithFee;

        return numerator / denominator;
    }

    /**
     * @dev Get pool key
     */
    function getPoolKey(string memory currency1, string memory currency2)
        internal
        pure
        returns (bytes32)
    {
        // Normalize order (alphabetical)
        if (keccak256(bytes(currency1)) < keccak256(bytes(currency2))) {
            return keccak256(abi.encodePacked(currency1, currency2));
        } else {
            return keccak256(abi.encodePacked(currency2, currency1));
        }
    }

    // Helper functions
    function sqrt(uint256 x) internal pure returns (uint256) {
        if (x == 0) return 0;
        uint256 z = (x + 1) / 2;
        uint256 y = x;
        while (z < y) {
            y = z;
            z = (x / z + z) / 2;
        }
        return y;
    }

    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }
}