آموزش ساخت کیف پول multi sig با سالیدیتی

npm install --save-dev hardhat

// SPDX-License-Identifier: MIT
pragma solidity ^.8.;

contract MultiSigWallet {
    address[] public owners;
    mapping(address => bool) public isOwner;
    uint public requiredSignatures;

    struct Transaction {
        address to;
        uint value;
        bool executed;
        uint confirmations;
    }

    Transaction[] public transactions;
    mapping(uint => mapping(address => bool)) public confirmations;

    event Deposit(address indexed sender, uint amount);
    event TransactionCreated(uint indexed transactionId, address indexed to, uint value);
    event TransactionConfirmed(uint indexed transactionId, address indexed owner);
    event TransactionExecuted(uint indexed transactionId);

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

    constructor(address[] memory _owners, uint _requiredSignatures) {
        require(_owners.length > , "At least one owner required");
        require(_requiredSignatures >  && _requiredSignatures <= _owners.length, "Invalid number of required signatures");

        for (uint i = ; i < _owners.length; i++) {
            require(!isOwner[_owners[i]], "Owner not unique");
            isOwner[_owners[i]] = true;
        }
        
        owners = _owners;
        requiredSignatures = _requiredSignatures;
    }

    receive() external payable {
        emit Deposit(msg.sender, msg.value);
    }

    function createTransaction(address _to, uint _value) public onlyOwner {
        uint transactionId = transactions.length;
        transactions.push(Transaction({
            to: _to,
            value: _value,
            executed: false,
            confirmations: 
        }));
        
        emit TransactionCreated(transactionId, _to, _value);
    }

    function confirmTransaction(uint _transactionId) public onlyOwner {
        require(_transactionId < transactions.length, "Transaction does not exist");
        require(!confirmations[_transactionId][msg.sender], "Transaction already confirmed");

        confirmations[_transactionId][msg.sender] = true;
        transactions[_transactionId].confirmations += 1;

        emit TransactionConfirmed(_transactionId, msg.sender);
    }

    function executeTransaction(uint _transactionId) public onlyOwner {
        require(_transactionId < transactions.length, "Transaction does not exist");
        require(transactions[_transactionId].confirmations >= requiredSignatures, "Not enough confirmations");
        require(!transactions[_transactionId].executed, "Transaction already executed");

        transactions[_transactionId].executed = true;
        (bool success, ) = transactions[_transactionId].to.call{value: transactions[_transactionId].value}("");
        require(success, "Transaction failed");

        emit TransactionExecuted(_transactionId);
    }
}

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("MultiSigWallet", function () {
    let MultiSigWallet;
    let multiSigWallet;
    let owner1, owner2, owner3;

    beforeEach(async function () {
        [owner1, owner2, owner3] = await ethers.getSigners();
        const owners = [owner1.address, owner2.address, owner3.address];
        const requiredSignatures = 2;

        MultiSigWallet = await ethers.getContractFactory("MultiSigWallet");
        multiSigWallet = await MultiSigWallet.deploy(owners, requiredSignatures);
        await multiSigWallet.deployed();
    });

    it("Should create and execute a transaction", async function () {
        await multiSigWallet.createTransaction(owner1.address, ethers.utils.parseEther("1"));

        await multiSigWallet.confirmTransaction();
        await multiSigWallet.connect(owner2).confirmTransaction();

        await expect(multiSigWallet.executeTransaction()).to.emit(multiSigWallet, "TransactionExecuted");
    });
});