《卡萨布兰卡》与跨链原子交换：里克咖啡馆作为DEX

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

import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract CasablancaDEX is AccessControl, ReentrancyGuard {
    bytes32 public constant TRADER_ROLE = keccak256("TRADER_ROLE");
    bytes32 public constant RELAYER_ROLE = keccak256("RELAYER_ROLE");

    enum SwapStatus {
        INITIATED, LOCKED, REDEEMED, REFUNDED, EXPIRED
    }

    struct AtomicSwap {
        bytes32 swapId;
        address initiator;
        address participant;
        address initiatorToken;
        address participantToken;
        uint256 initiatorAmount;
        uint256 participantAmount;
        bytes32 hashLock;
        uint256 timelock;
        SwapStatus status;
        uint256 createdAt;
        bytes32 secret;
    }

    struct LiquidityPool {
        address tokenA;
        address tokenB;
        uint256 reserveA;
        uint256 reserveB;
        uint256 fee;
        bool isActive;
    }

    mapping(bytes32 => AtomicSwap) public swaps;
    mapping(bytes32 => LiquidityPool) public pools;

    uint256 public swapCount;
    uint256 public poolCount;
    uint256 public totalVolume;
    uint256 public swapFee = 30; // 0.3%

    event SwapInitiated(bytes32 indexed swapId, address indexed initiator, address indexed participant);
    event SwapLocked(bytes32 indexed swapId);
    event SwapRedeemed(bytes32 indexed swapId, bytes32 secret);
    event SwapRefunded(bytes32 indexed swapId);
    event PoolCreated(bytes32 indexed poolId, address tokenA, address tokenB);

    function initiateSwap(
        address _participant,
        address _initiatorToken,
        address _participantToken,
        uint256 _initiatorAmount,
        uint256 _participantAmount,
        bytes32 _hashLock,
        uint256 _timelock
    ) external returns (bytes32) {
        swapCount++;
        bytes32 swapId = keccak256(abi.encodePacked(
            msg.sender, _participant, swapCount, block.timestamp
        ));

        swaps[swapId] = AtomicSwap({
            swapId: swapId,
            initiator: msg.sender,
            participant: _participant,
            initiatorToken: _initiatorToken,
            participantToken: _participantToken,
            initiatorAmount: _initiatorAmount,
            participantAmount: _participantAmount,
            hashLock: _hashLock,
            timelock: _timelock,
            status: SwapStatus.INITIATED,
            createdAt: block.timestamp,
            secret: bytes32(0)
        });

        IERC20(_initiatorToken).transferFrom(msg.sender, address(this), _initiatorAmount);
        emit SwapInitiated(swapId, msg.sender, _participant);
        return swapId;
    }

    function lockSwap(bytes32 _swapId) external {
        AtomicSwap storage swap = swaps[_swapId];
        require(swap.status == SwapStatus.INITIATED, "Swap not initiated");
        require(msg.sender == swap.participant, "Not the participant");

        swap.status = SwapStatus.LOCKED;
        IERC20(swap.participantToken).transferFrom(msg.sender, address(this), swap.participantAmount);

        emit SwapLocked(_swapId);
    }

    function redeemSwap(bytes32 _swapId, bytes32 _secret) external {
        AtomicSwap storage swap = swaps[_swapId];
        require(swap.status == SwapStatus.LOCKED, "Swap not locked");
        require(block.timestamp < swap.timelock, "Swap expired");
        require(keccak256(abi.encodePacked(_secret)) == swap.hashLock, "Invalid secret");

        swap.status = SwapStatus.REDEEMED;
        swap.secret = _secret;

        IERC20(swap.participantToken).transfer(swap.initiator, swap.participantAmount);
        IERC20(swap.initiatorToken).transfer(swap.participant, swap.initiatorAmount);

        totalVolume += swap.initiatorAmount + swap.participantAmount;
        emit SwapRedeemed(_swapId, _secret);
    }

    function refundSwap(bytes32 _swapId) external nonReentrant {
        AtomicSwap storage swap = swaps[_swapId];
        require(swap.status == SwapStatus.LOCKED, "Swap not locked");
        require(block.timestamp >= swap.timelock, "Timelock not expired");

        swap.status = SwapStatus.REFUNDED;
        IERC20(swap.initiatorToken).transfer(swap.initiator, swap.initiatorAmount);
        IERC20(swap.participantToken).transfer(swap.participant, swap.participantAmount);

        emit SwapRefunded(_swapId);
    }

    function createPool(
        address _tokenA,
        address _tokenB,
        uint256 _fee
    ) external onlyRole(RELAYER_ROLE) returns (bytes32) {
        poolCount++;
        bytes32 poolId = keccak256(abi.encodePacked(_tokenA, _tokenB, poolCount));

        pools[poolId] = LiquidityPool({
            tokenA: _tokenA,
            tokenB: _tokenB,
            reserveA: 0,
            reserveB: 0,
            fee: _fee,
            isActive: true
        });

        emit PoolCreated(poolId, _tokenA, _tokenB);
        return poolId;
    }

    function getSwapStatus(bytes32 _swapId) external view returns (SwapStatus) {
        return swaps[_swapId].status;
    }

    function calculateSwapPrice(bytes32 _poolId, uint256 _amountIn) external view returns (uint256) {
        LiquidityPool storage pool = pools[_poolId];
        require(pool.isActive, "Pool not active");

        uint256 amountInWithFee = _amountIn * (10000 - pool.fee);
        uint256 numerator = amountInWithFee * pool.reserveB;
        uint256 denominator = (pool.reserveA * 10000) + amountInWithFee;
        return numerator / denominator;
    }
}

import hashlib
import json
from typing import Dict, List, Optional, Tuple
from dataclasses import dataclass
from datetime import datetime, timedelta
import random
import secrets

@dataclass
class AtomicSwap:
    swap_id: str
    initiator: str
    participant: str
    initiator_token: str
    participant_token: str
    initiator_amount: float
    participant_amount: float
    hash_lock: str
    timelock: int
    status: str
    secret: str

class CasablancaDEX:
    def __init__(self):
        self.swaps: Dict[str, AtomicSwap] = {}
        self.pools: Dict[str, Dict] = {}
        self.swap_count = 0
        self.total_volume = 0

    def initiate_swap(self, initiator: str, participant: str, initiator_token: str,
                      participant_token: str, initiator_amount: float,
                      participant_amount: float, timelock: int) -> Tuple[AtomicSwap, str]:
        self.swap_count += 1
        secret = secrets.token_hex(32)
        hash_lock = hashlib.sha256(secret.encode()).hexdigest()
        swap_id = hashlib.sha256(f"{initiator}{participant}{self.swap_count}".encode()).hexdigest()[:16]

        swap = AtomicSwap(
            swap_id=swap_id,
            initiator=initiator,
            participant=participant,
            initiator_token=initiator_token,
            participant_token=participant_token,
            initiator_amount=initiator_amount,
            participant_amount=participant_amount,
            hash_lock=hash_lock,
            timelock=timelock,
            status='initiated',
            secret=''
        )
        self.swaps[swap_id] = swap
        return swap, secret

    def lock_swap(self, swap_id: str, participant: str) -> Dict:
        swap = self.swaps.get(swap_id)
        if not swap or swap.status != 'initiated' or swap.participant != participant:
            return {'success': False, 'error': 'Invalid swap'}

        swap.status = 'locked'
        return {'success': True}

    def redeem_swap(self, swap_id: str, secret: str) -> Dict:
        swap = self.swaps.get(swap_id)
        if not swap or swap.status != 'locked':
            return {'success': False, 'error': 'Swap not locked'}

        if datetime.now().timestamp() > swap.timelock:
            return {'success': False, 'error': 'Swap expired'}

        if hashlib.sha256(secret.encode()).hexdigest() != swap.hash_lock:
            return {'success': False, 'error': 'Invalid secret'}

        swap.status = 'redeemed'
        swap.secret = secret
        self.total_volume += swap.initiator_amount + swap.participant_amount

        return {'success': True, 'secret': secret}

    def refund_swap(self, swap_id: str) -> Dict:
        swap = self.swaps.get(swap_id)
        if not swap or swap.status != 'locked':
            return {'success': False, 'error': 'Swap not locked'}

        if datetime.now().timestamp() < swap.timelock:
            return {'success': False, 'error': 'Timelock not expired'}

        swap.status = 'refunded'
        return {'success': True}

    def create_pool(self, token_a: str, token_b: str, fee: int = 30) -> Dict:
        pool_id = hashlib.sha256(f"{token_a}{token_b}{datetime.now()}".encode()).hexdigest()[:16]
        pool = {
            'pool_id': pool_id,
            'token_a': token_a,
            'token_b': token_b,
            'reserve_a': 0,
            'reserve_b': 0,
            'fee': fee,
            'is_active': True
        }
        self.pools[pool_id] = pool
        return pool

    def simulate_casablanca_swap(self) -> Dict:
        rick = '0xRick'
        ilsa = '0xIlsa'
        swap, secret = self.initiate_swap(rick, ilsa, 'ETH', 'USDC', 1, 2000, int((datetime.now() + timedelta(hours=24)).timestamp()))
        self.lock_swap(swap.swap_id, ilsa)
        result = self.redeem_swap(swap.swap_id, secret)
        return {
            'swap_id': swap.swap_id,
            'initiator': rick,
            'participant': ilsa,
            'status': result['status'],
            'volume': self.total_volume
        }

dex = CasablancaDEX()
result = dex.simulate_casablanca_swap()
print(f"Swap {result['swap_id']}: {result['status']}")

const { ethers } = require('ethers');
const crypto = require('crypto');

class CasablancaDEXClient {
  constructor(providerUrl) {
    this.provider = new ethers.providers.JsonRpcProvider(providerUrl);
    this.swaps = new Map();
    this.pools = new Map();
    this.swapCount = 0;
    this.totalVolume = ethers.BigNumber.from(0);
  }

  async initiateSwap(initiator, participant, initiatorToken, participantToken, initiatorAmount, participantAmount, timelock) {
    this.swapCount++;
    const secret = crypto.randomBytes(32).toString('hex');
    const hashLock = crypto.createHash('sha256').update(secret).digest('hex');
    const swapId = ethers.utils.keccak256(
      ethers.utils.toUtf8Bytes(`${initiator}${participant}${this.swapCount}`)
    ).slice(0, 18);

    const swap = {
      swapId,
      initiator,
      participant,
      initiatorToken,
      participantToken,
      initiatorAmount: ethers.utils.parseEther(initiatorAmount.toString()),
      participantAmount: ethers.utils.parseEther(participantAmount.toString()),
      hashLock,
      timelock: Math.floor(Date.now() / 1000) + timelock,
      status: 'initiated',
      secret: ''
    };

    this.swaps.set(swapId, swap);
    return { swap, secret };
  }

  async lockSwap(swapId, participant) {
    const swap = this.swaps.get(swapId);
    if (!swap || swap.status !== 'initiated' || swap.participant !== participant) {
      return { success: false };
    }
    swap.status = 'locked';
    return { success: true };
  }

  async redeemSwap(swapId, secret) {
    const swap = this.swaps.get(swapId);
    if (!swap || swap.status !== 'locked') return { success: false };

    const hashLock = crypto.createHash('sha256').update(secret).digest('hex');
    if (hashLock !== swap.hashLock) return { success: false, error: 'Invalid secret' };

    swap.status = 'redeemed';
    swap.secret = secret;
    this.totalVolume = this.totalVolume.add(swap.initiatorAmount).add(swap.participantAmount);

    return { success: true };
  }

  async refundSwap(swapId) {
    const swap = this.swaps.get(swapId);
    if (!swap || swap.status !== 'locked') return { success: false };
    swap.status = 'refunded';
    return { success: true };
  }
}

const client = new CasablancaDEXClient('https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY');
const { swap, secret } = client.initiateSwap('0xRick', '0xIlsa', 'ETH', 'USDC', 1, 2000, 86400);
console.log('Swap initiated:', swap.swapId);