多签钱包与影视基金：多方控制的资金管理

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

contract FilmMultiSigWallet {
    struct Transaction {
        address to;
        uint256 value;
        bytes data;
        string description;
        bool executed;
        uint256 confirmations;
        uint256 timestamp;
    }

    mapping(address => bool) public isOwner;
    address[] public owners;
    uint256 public required;
    uint256 public transactionCount;
    mapping(uint256 => Transaction) public transactions;
    mapping(uint256 => mapping(address => bool)) public confirmations;

    event TransactionSubmitted(uint256 indexed txId, address indexed to, uint256 value);
    event Confirmation(address indexed sender, uint256 indexed txId);
    event Execution(uint256 indexed txId);
    event OwnerAdded(address indexed owner);
    event OwnerRemoved(address indexed owner);

    modifier onlyOwner() {
        require(isOwner[msg.sender], "Not owner");
        _;
    }

    modifier txExists(uint256 txId) {
        require(txId < transactionCount, "Tx does not exist");
        _;
    }

    modifier notConfirmed(uint256 txId) {
        require(!confirmations[txId][msg.sender], "Already confirmed");
        _;
    }

    modifier notExecuted(uint256 txId) {
        require(!transactions[txId].executed, "Already executed");
        _;
    }

    constructor(address[] memory _owners, uint256 _required) {
        require(_owners.length > 0, "Owners required");
        require(_required > 0 && _required <= _owners.length, "Invalid required");

        for (uint256 i = 0; i < _owners.length; i++) {
            require(_owners[i] != address(0), "Invalid owner");
            require(!isOwner[_owners[i]], "Duplicate owner");
            isOwner[_owners[i]] = true;
            owners.push(_owners[i]);
        }
        required = _required;
    }

    function submitTransaction(address to, uint256 value, bytes calldata data, 
                               string calldata description) external onlyOwner returns (uint256) {
        uint256 txId = transactionCount;
        transactions[txId] = Transaction({
            to: to,
            value: value,
            data: data,
            description: description,
            executed: false,
            confirmations: 0,
            timestamp: block.timestamp
        });
        transactionCount++;
        emit TransactionSubmitted(txId, to, value);
        return txId;
    }

    function confirmTransaction(uint256 txId) external onlyOwner txExists(txId) notConfirmed(txId) {
        transactions[txId].confirmations++;
        confirmations[txId][msg.sender] = true;
        emit Confirmation(msg.sender, txId);
    }

    function executeTransaction(uint256 txId) external onlyOwner txExists(txId) notExecuted(txId) {
        require(transactions[txId].confirmations >= required, "Not enough confirmations");
        Transaction storage txn = transactions[txId];
        txn.executed = true;
        (bool success, ) = txn.to.call{value: txn.value}(txn.data);
        require(success, "Tx failed");
        emit Execution(txId);
    }

    function addOwner(address owner) external onlyOwner {
        require(!isOwner[owner], "Already owner");
        isOwner[owner] = true;
        owners.push(owner);
        emit OwnerAdded(owner);
    }

    function removeOwner(address owner) external onlyOwner {
        require(isOwner[owner], "Not owner");
        isOwner[owner] = false;
        for (uint256 i = 0; i < owners.length; i++) {
            if (owners[i] == owner) {
                owners[i] = owners[owners.length - 1];
                owners.pop();
                break;
            }
        }
        require(required <= owners.length, "Required > owners");
        emit OwnerRemoved(owner);
    }

    function getOwners() external view returns (address[] memory) {
        return owners;
    }
}

const express = require('express');
const { ethers } = require('ethers');
const app = express();
app.use(express.json());

const MULTISIG_ABI = [
    "function submitTransaction(address to, uint256 value, bytes data, string description) external returns (uint256)",
    "function confirmTransaction(uint256 txId) external",
    "function executeTransaction(uint256 txId) external",
    "function getOwners() external view returns (address[])",
    "event TransactionSubmitted(uint256 indexed txId, address indexed to, uint256 value)",
    "event Confirmation(address indexed sender, uint256 indexed txId)",
    "event Execution(uint256 indexed txId)"
];

class FilmFundManager {
    constructor(providerUrl, walletAddress) {
        this.provider = new ethers.providers.JsonRpcProvider(providerUrl);
        this.wallet = new ethers.Contract(walletAddress, MULTISIG_ABI, this.provider);
    }

    async submitTransaction(privateKey, to, value, description) {
        const wallet = new ethers.Wallet(privateKey, this.provider);
        const contract = this.wallet.connect(wallet);
        const tx = await contract.submitTransaction(to, 
            ethers.utils.parseEther(value.toString()), '0x', description);
        return await tx.wait();
    }

    async confirmTransaction(privateKey, txId) {
        const wallet = new ethers.Wallet(privateKey, this.provider);
        const contract = this.wallet.connect(wallet);
        const tx = await contract.confirmTransaction(txId);
        return await tx.wait();
    }

    async executeTransaction(privateKey, txId) {
        const wallet = new ethers.Wallet(privateKey, this.provider);
        const contract = this.wallet.connect(wallet);
        const tx = await contract.executeTransaction(txId);
        return await tx.wait();
    }
}

app.post('/api/fund/submit', async (req, res) => {
    const { privateKey, to, value, description } = req.body;
    const manager = new FilmFundManager(process.env.RPC_URL, process.env.MULTISIG_ADDRESS);
    const receipt = await manager.submitTransaction(privateKey, to, value, description);
    res.json(receipt);
});

app.post('/api/fund/confirm', async (req, res) => {
    const { privateKey, txId } = req.body;
    const manager = new FilmFundManager(process.env.RPC_URL, process.env.MULTISIG_ADDRESS);
    const receipt = await manager.confirmTransaction(privateKey, txId);
    res.json(receipt);
});

app.listen(3013, () => {
    console.log('Film Fund API running on port 3013');
});