Hi @DanDD for all public state variables (variables that aren’t declared inside a function) automatic getters are generated it means if you program a contract like this:
pragma solidity 0.7.5;
contract PublicGetter {
uint public num;
}
You automatically get a function num which will give the state variable value. You can read a bit more in solidity documentation in Visibility and Getters Contracts Documentation
Hi @tom88norman well done! You figured out how to finish the project so I think that’s a great step! I try to follow Mark Zuckerberg quote Done is better than perfect so about your points I think:
constructor(address[] memory _owners, uint _limitApprovals) Ownables(_owners){
limitApprovals = _limitApprovals;
}
If you can see after the function parameters I called the parent class and pass the owners array that I received from the constructor.
I saw your code and I think it’s a good approach as long as you don’t need a transaction log maybe you could emit events for every transaction step how Filip did in his code.
I have a similar doubt about the better way to avoid gas increasing, my approach was setting a state for every transaction without removing it but I think in long term is expensive because I don’t get rid of transactions so as long as more transactions we have more space we need to use it means more costs. Maybe someone can help us with this doubt.
I think we have to read solidity style guide to be aware if we’re following the conventions.
Hi, first of all, this was an interesting project, we have to use what we learned to solve it! so thank Filip for this project.
Steps
I used 2 files, 1 for managing all owners permissions and the another for wallet logic
ownables.sol
pragma solidity 0.7.5;
contract Ownables{
address[] owners;
constructor(address[] memory _owners){
owners = _owners;
}
modifier isOwner () {
bool owner = false;
uint index = 0;
while( index < owners.length && owner == false) {
owner = owners[index] == msg.sender;
index++;
}
require(owner, "Just owner can use this method");
_;
}
function ownerDifferentThanRequestor(address _requestorAddress) internal {
if (_requestorAddress == msg.sender) {
revert("approvers have to be different than requestor");
}
}
}
wallet.sol
pragma solidity 0.7.5;
import "ownables.sol";
contract Wallet is Ownables{
//minimum approvals to do the transaction.
uint limitApprovals;
struct PendingTransaction{
address requestor;
address to;
uint amount;
uint id;
address[] approvers;
bool completed;
}
PendingTransaction[] pendingTransactions;
constructor(address[] memory _owners, uint _limitApprovals) Ownables(_owners){
limitApprovals = _limitApprovals;
}
receive() payable external{}
modifier checkWalletBalanceModifier(uint _amount){
checkWalletBalance(_amount);
_;
}
function deposit() external payable{
}
function checkWalletBalance(uint _amount) private view {
require(_amount <= address(this).balance, "Wallet not have enough balance try with less amount");
}
function findApproversByTransactionId(uint transactionId) private view returns(PendingTransaction storage) {
uint loop = 0;
while(loop < pendingTransactions.length) {
if(pendingTransactions[loop].id == transactionId){
return pendingTransactions[loop];
}
loop++;
}
revert("Transaction not found");
}
function existApprover(address[] storage approvers) private view returns(bool) {
uint loop = 0;
while( loop < approvers.length) {
if(approvers[loop] == msg.sender){
return true;
}
loop++;
}
return false;
}
function transfer(address _to, uint _amount) isOwner checkWalletBalanceModifier(_amount) external {
require(address(this).balance >= _amount);
address[] memory approvers;
pendingTransactions.push(
PendingTransaction(msg.sender, _to, _amount, pendingTransactions.length, approvers, false)
);
}
// Check if transaction id exist
// Check if who is approving is different than requestor (who created the transaction)
// Check if transaction was completed
// Check if the owner has an approval
function approveTransfer(uint transactionId) isOwner external{
PendingTransaction storage pendingTransaction = findApproversByTransactionId(transactionId);
ownerDifferentThanRequestor(pendingTransaction.requestor);
bool oldApprover = existApprover(pendingTransaction.approvers);
if(pendingTransaction.completed){
revert("Transaction had been completed already");
}
if(oldApprover){
revert("You had approved already");
}
checkWalletBalance(pendingTransaction.amount);
pendingTransaction.approvers.push(msg.sender);
if(pendingTransaction.approvers.length == limitApprovals){
pendingTransaction.completed = true;
payable(pendingTransaction.to).transfer(pendingTransaction.amount);
}
}
}
Doubt
Here’s my code, forgot to add the events.
pragma solidity >=0.5.0 <0.9.0;
contract Multisig {
mapping(address => bool) owner;
uint8 limitApproval;
mapping(uint => Transfer) public transfers;
uint public transfersCount = 0;
mapping(address => mapping(uint => bool)) signers;
enum TransferStatus { Sent, Pending }
struct Transfer {
address payable to;
uint amount;
TransferStatus status;
uint approvals;
uint id;
}
modifier onlyOwner {
require(owner[msg.sender], "You're not an owner");
_;
}
constructor(address[] memory _owners, uint8 _limitApproval) {
for(uint i = 0; i < _owners.length; i++) {
owner[_owners[i]] = true;
}
limitApproval = _limitApproval;
}
function deposit() public payable {}
function getBalance() public view returns(uint) {
return address(this).balance;
}
function createTransfer(address payable _to, uint _amount) public onlyOwner {
uint txId = transfersCount;
transfers[txId] = Transfer(_to, _amount, TransferStatus.Pending, 0, txId);
approveTransfer(txId);
transfersCount++;
}
function approveTransfer(uint _id) public onlyOwner {
require(signers[msg.sender][_id] == false, "Already approved");
Transfer storage transfer = transfers[_id];
signers[msg.sender][_id] = true;
transfer.approvals++;
if(transfer.approvals >= limitApproval ) {
_executeTransfer(transfer);
}
}
function _executeTransfer(Transfer storage _transfer) private {
_transfer.to.transfer(_transfer.amount);
_transfer.status = TransferStatus.Sent;
}
}
pragma solidity 0.7.5;
pragma abicoder v2;
/*
- Anyone should be able to deposit ether into the smart contract
– The contract creator should be able to input (1): the addresses of the owners and (2): the numbers of approvals required for a transfer, in the constructor. For example, input 3 addresses and set the approval limit to 2.
– Anyone of the owners should be able to create a transfer request. The creator of the transfer request will specify what amount and to what address the transfer will be made.
– Owners should be able to approve transfer requests.
– When a transfer request has the required approvals, the transfer should be sent.
*/
contract multiSigWallet{
address[] public owners;
uint limit;
struct transfer{
uint amount;
address payable recipient;
uint approvals;
bool sent;
uint id;
}
transfer[] transferRequests;
event TransferRequestCreated(uint id, uint amount, address initiator, address recipient);
event ApprovalReceived(uint id, uint approvals, address approver);
event TransferApproved(uint id);
mapping(address =>mapping(uint => bool)) approvals;
//mapping[address][transfer id] => true/false
//mapping[msg.sender][5] = true;
modifier onlyOwners(){
bool isOwner = false;
for(uint i = 0; i < owners.length; i++){
if(owners[i] == msg.sender){
isOwner = true;
}
}
require(isOwner == true);
_;
}
constructor(address[] memory _owners, uint _limit){
owners = _owners;
limit = _limit;
}
function deposit() public payable{}
function createTransfer(uint _amount,address payable _recipient) public onlyOwners{
require(address(this).balance >= _amount);
emit TransferRequestCreated(transferRequests.length, _amount, msg.sender, _recipient);
transferRequests.push(
transfer(_amount,_recipient,0,false,transferRequests.length)
);
}
function approve(uint id) public onlyOwners{
require(approvals[msg.sender][id] == false);
require(transferRequests[id].sent == false);
approvals[msg.sender][id] = true;
transferRequests[id].approvals++;
emit ApprovalReceived(id,transferRequests[id].approvals,msg.sender);
if(transferRequests[id].approvals >= limit){
transferRequests[id].sent = true;
transferRequests[id].recipient.transfer(transferRequests[id].amount);
emit TransferApproved(id);
}
}
function getTransferRequests() public view returns(transfer[] memory){
return transferRequests;
}
function getBalance() public view returns(uint){
return address(this).balance;
}
}
My first attempt, before watching any of the hints.
This multisig wallet has 3 authorised signatories, and the creator can choose to require 2/3 or 3/3 approvals for each transfer request to be sent.
Where only 2/3 approvals are required, if the beneficiary is one of the authorised signatories, the other 2 signatories must approve the transfer request for it to be sent.
Where 3/3 approvals are required, if the beneficiary is one of the authorised signatories, only the other 2 signatories must approve the transfer request for it to be sent.
An authorised signatory can create a new transfer request with themselves as the beneficiary and, in doing so, will be recorded as the 1st authorised signatory in the approval process for that transfer. However, as the other 2 signatories must then go on to approve such a transfer request for it to be sent, the 1st authorised signatory will not be counted as one of the 2 approvals required in these cases.
ownable.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.7.5;
contract Ownable {
address public owner; // contract creator
modifier onlyOwner {
require(msg.sender == owner, "Operation restricted to contract creator");
_;
}
constructor() {
owner = msg.sender;
}
}
approval.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.7.5;
import "./ownable.sol";
contract Approval is Ownable {
// 3 signatories authorised to approve transfers, set by constructor
address[3] public auth;
// 2 or all 3 of the authorised signatories required to approve each transfer,
// set by constructor
uint8 public approvals;
event Approvals(uint8 required);
event SignatoryChanged(address removedAuth, address newAuth);
modifier onlyAuth {
require(
msg.sender == auth[0] || msg.sender == auth[1] || msg.sender == auth[2],
"Operation restricted to authorised signatories"
);
_;
}
constructor(uint8 _approvals, address _auth1, address _auth2, address _auth3) {
require(
_approvals == 2 || _approvals == 3,
"Required approvals must be 2 or 3 (out of 3)"
);
require(
_auth1 != _auth2 && _auth1 != _auth3 && _auth2 != _auth3,
"Each authorised signatory must be a different address"
);
approvals = _approvals;
auth[0] = _auth1;
auth[1] = _auth2;
auth[2] = _auth3;
}
function changeRequiredApprovals() external onlyOwner {
approvals == 3 ? approvals = 2 : approvals = 3;
emit Approvals(approvals);
}
function changeSignatory(uint8 authNum, address newAuth) external onlyOwner {
require(authNum >= 1 && authNum <= 3, "Select signatory 1, 2 or 3");
require(
newAuth != auth[authNum - 1],
"New authorised signatory should be different from the one it is replacing"
);
require(
newAuth != auth[0] && newAuth != auth[1] && newAuth != auth[2],
"New authorised signatory must be different from the other two"
);
address priorAuth = auth[authNum - 1];
auth[authNum - 1] = newAuth;
emit SignatoryChanged(priorAuth, auth[authNum - 1]);
}
}
multisigWallet.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.7.5;
// pragma abicoder v2;
import "./approval.sol";
contract MultisigWallet is Approval {
constructor(uint8 _approvals, address _auth1, address _auth2, address _auth3)
Approval(_approvals, _auth1, _auth2, _auth3) {}
struct Request {
bool pending;
address beneficiary;
uint256 amount;
uint8 stillRequired; // Number of approvals still required
address sig1;
address sig2;
address rejected; /* Records signatory if they reject a transfer request but it
remains "Pending". This can only occur where 2 out of 3 approvals are required */
}
// Stores a transfer request pending further approval, until either sent or fully rejected
Request private request;
event Transfer(
string status, uint8 stillRequired, address auth, address beneficiary, uint256 amount
);
function getBalance() external view returns(uint256 balance) {
return address(this).balance;
}
function deposit() external payable {}
/* Any of the 3 authorised signatories can create a new transfer request and provide
1st approval, pending 1 or 2 further approvals from the other signatories.
(Note, no 1st approval is counted at this stage when the creator of the transfer
request is also the beneficiary, as explained in the introductory notes) */
function createRequest(address _beneficiary, uint256 _amount) external onlyAuth {
// Can only create a new request if there isn't one already pending
require(!request.pending, "There is already a request awaiting approval");
/* The transfer method would throw an error and revert the approveOrReject()
function if it eventually attempted to send a transfer when there was an
insufficient contract balance to cover it.
But this contract balance check is performed when transfer requests are
created, in order to prevent those which are likely to fail from going
through the approval process unnecessarily and wasting time, gas and storage */
require(address(this).balance >= _amount, "Insufficient funds");
request.pending = true;
request.beneficiary = _beneficiary;
request.amount = _amount;
request.sig1 = msg.sender;
// Establishes number of approvals still required
if (
/* If 2/3 approvals required, and creator of new request is also
the beneficiary, then 2 further approvals still required */
approvals == 2 && _beneficiary != msg.sender ||
/* If all 3 approvals required, but one of other 2 signatories is also the
beneficiary, then only 1 further approval required (i.e. total reduced to 2 */
approvals == 3 && _beneficiary != msg.sender &&
(_beneficiary == auth[0] || _beneficiary == auth[1] || _beneficiary == auth[2])
) {
request.stillRequired = 1;
}
else request.stillRequired = 2;
emit Transfer("Pending", request.stillRequired, msg.sender, _beneficiary, _amount);
}
/* An authorised signatory can check if there is a transfer request
awaiting their approval, and can view the details if there is */
function needsMyApproval() external view onlyAuth returns(
address beneficiary, uint256 amount, uint256 stillRequired,
address sig1, address sig2, address notSignedBy
) {
require(request.pending, "There is no pending transfer request");
require(
request.beneficiary != msg.sender &&
request.sig1 != msg.sender &&
request.sig2 != msg.sender &&
request.rejected != msg.sender,
"There is no transfer request awaiting your approval"
);
return (
request.beneficiary, request.amount, request.stillRequired,
request.sig1, request.sig2, request.rejected
);
}
/* Any address can get details of a pending transfer request,
whether or not it requires their approval */
function getPendingRequest() external view returns(
address beneficiary, uint256 amount, uint256 stillRequired,
address sig1, address sig2, address notSignedBy
) {
require(request.pending, "There is no pending transfer request");
return (
request.beneficiary, request.amount, request.stillRequired,
request.sig1, request.sig2, request.rejected
);
}
/*
// Same function, but returning whole struct instance instead of separate values
// Need to uncomment pragma abicoder v2;
function getPendingRequest() external view returns(Request memory) {
require(request.pending, "There is no pending transfer request");
return request;
}
*/
// Other authorised signatories approve or reject a pending transfer request
// Boolean parameter: true (approve/sign), false (reject/don't sign)
function approveOrReject(bool approve) external onlyAuth {
require(request.pending, "There is no pending transfer request");
require(request.rejected != msg.sender, "You have already rejected this transfer request");
require(
request.beneficiary != msg.sender,
"You cannot approve or reject this transfer request, because you are the beneficiary"
);
require(
request.sig1 != msg.sender && request.sig2 != msg.sender,
"You have already approved this transfer request"
);
address recipient = request.beneficiary;
if (
approvals == 3 || approve || request.rejected != address(0) ||
recipient == auth[0] || recipient == auth[1] || recipient == auth[2]
) {
request.stillRequired--;
}
uint256 amount = request.amount;
string memory status;
if (request.stillRequired == 0 && approve) {
delete request;
payable(recipient).transfer(amount);
status = "Sent";
}
else if (
request.stillRequired == 0 ||
request.stillRequired == 1 && !approve &&
(approvals == 3 || recipient == request.sig1)
) {
delete request;
status = "Rejected";
}
else if (approve) {
request.sig2 = msg.sender;
status = "Pending";
}
else {
request.rejected = msg.sender;
status = "Rejected / Still Pending";
}
emit Transfer(status, request.stillRequired, msg.sender, recipient, amount);
}
}
the master is hereee ahhha. really cool project jon. really like your segregation of the approvals logic into its own contract. great solution
This is a question about loading the contract with Ethereum.
According to what I’ve read, a contract has to add these special functions to receive ether:
receive() external payable {}
fallback() external payable {}
But when I add those two functions, Remix doesn’t expose them in the UI for me to call. I can’t send ether to the contract this way. I had to add my own “deposit” function. Why did I need to do this? Why doesn’t remix expose those two functions to call from the User Interface?
@Placebo you need to make a deposit function if you want to be able to send ether “into” your contract and use msg.value to specify the amount you want to send. The deposit function also needs to be payable. However if you want to send ether into a smart contract from another contract you can also will need to write a function called transfer to do this something like this
function transfer(address payable receiverAddress, uint256 amount) public {
require(balance[msg.sender] >= amount, "insufficent funds");
require(amount >= 0, "cannot send 0 amount");
balance[msg.sender] -= amount;
receiverAddress.transfer(amount);
}
@Placebo. Heres a good post for you to read on the two functions you mentioned for extra reading
https://stackoverflow.com/questions/69178874/solidity-v0-6-0-fallback-functions-what-are-they-needed-for
Note: Since this contract doesn’t keep separate accounts, I just use the built-in balance function of the contract address(this).balance itself to manage how much money is available.
Wallet.sol
pragma solidity >=0.8.7;
//pragma abicoder v2;
// SPDX-License-Identifier: asdf
import “./Lockable.sol”;
contract Wallet is Lockable{
address[] Owners;
uint Required;
struct Transfer {
address towhom;
uint howmuch;
uint whenSent;
address[] approvers;
}
Transfer[] Transfers;
modifier onlyOwners() {
require(FindAddress(msg.sender, Owners), "Only an owner can do this.");
_;
}
//– The contract creator should be able to input (1): the addresses of the owners and
// (2): the numbers of approvals required for a transfer, in the constructor.
// For example, input 3 addresses and set the approval limit to 2.
constructor(uint _required_approvals, address[] memory _owners) {
Owners = _owners;
Required = _required_approvals;
}
//– Anyone of the owners should be able to create a transfer request.
// The creator of the transfer request will specify what amount
// and to what address the transfer will be made.
function InitiateTransfer(address _towhom, uint _howmuch) public onlyOwners returns(uint) {
require(address(this).balance >= _howmuch, "Not enough ether to send the requested amount");
address[] memory a;
Transfers.push(Transfer(_towhom, _howmuch, 0, a));
//optional if Initiator should be implictly considered an approval, for now, no.
//Transfers[Transfers.length - 1].approvers.push(msg.sender);
return Transfers.length - 1;
}
// because mappings can't be nested in structs, need to simulate a mapping using an array
function FindAddress(address _find, address[] storage _addresses) private view returns(bool) {
for (uint id = 0; id < _addresses.length; id++) {
if (_find == _addresses[id]) {
return true;
}
}
return false;
}
//– Owners should be able to approve transfer requests.
function Approve(uint _id) public onlyOwners lockable returns (uint) {
require(FindAddress(msg.sender, Transfers[_id].approvers) == false, "You cannot approve more than once.");
Transfers[_id].approvers.push(msg.sender); // new approver? Add to approver list for that transfer
if (Transfers[_id].approvers.length < Required) {
return Transfers[_id].approvers.length; // don't send yet, tell caller how many approvals exist currently
}
require(address(this).balance >= Transfers[_id].howmuch, "Wallet does not have enough to send this.");
// check for already spent and simultaneously set "already sent" (non zero whenSent)
// another way to block multiple callers though there is a slight slot where this could happen
// if ++ is not atomic in the EVM.
require(Transfers[_id].whenSent++ == 0, "Transaction has already been sent.");
Transfers[_id].whenSent = block.timestamp; // prevent recursive exploit (towhom calling back to Approve)
//– When a transfer request has the required approvals, the transfer should be sent.
// if this hangs, the Lock (see lockable modifier) will stay in place forever???
(bool sent, bytes memory data) = Transfers[_id].towhom.call{value: Transfers[_id].howmuch}("");
if (sent == false) {
// if the send failed, fix up the whenSent to be not-sent yet
Transfers[_id].whenSent = 0;
Transfers[_id].approvers.pop(); // remove the last approver so he can retry
require(sent, "Transfer failed at receiving end");
}
return Transfers[_id].approvers.length;
}
function AddOwner(address _newowner) public onlyOwners {
require(FindAddress(_newowner, Owners) == false, "Already an owner");
Owners.push(_newowner);
}
//– Anyone should be able to deposit ether into the smart contract
function deposit() payable public returns (uint){
return GetBalance();
}
function GetBalance() public view returns (uint) {
return address(this).balance;
}
}
Lockable.sol
pragma solidity >=0.8.7;
//pragma abicoder v2;
// SPDX-License-Identifier: asdf
// Mutual Exclusion - Prevent multiple callers inside a function at the same time
contract Lockable {
uint Locked;
constructor() {
Locked = 0;
}
modifier lockable() {
if (Locked++ > 0) {
require(false, "Busy, try again");
}
_;
Locked = 0;
}
A master piece from the most detailed and incredible teacher we have!
Love all the descriptions which make easier to understand what each function does 
Big hug to you Big J!
A second version of my original solution after watching the first support video.
Modifications:
Added the double mapping to store each authorised signatory’s approvals of transfer requests. I no longer record the addresses, as they approve each request, within each Request instance.
Transfer requests can now be created while others are still pending. Each newly created transfer request is added to a requests array, where they remain stored even after having been sent or fully rejected. Two Boolean properties have been added to the Request struct to record whether each transfer request is eventually sent or fully rejected, so that this information is retained for transfers which are no longer pending.
Each transfer request is now given an ID number when it’s created:
ID number = index number of Request instance in requests array + 1
The IDs are stored as a separate property in each Request instance.
Each authorised signatory can call the forMyApproval() function to retrieve an array of all the pending transfer request IDs which they are entitled to approve. They can then call the getTransfer() function or the getTransferDetails function with a specific ID from this array in order to retrieve its data, and then proceed to call the approveOrReject() function with the same ID to either approve or reject that specific transfer request.
The forMyApproval array() iterates over the array of stored transfer requests and adds each qualifying ID to a fixed-size memory array. The fixed size of the array is a variable which is determined for each authorised signatory by referencing the total number of pending transfer requests they are currently entitled to approve, and which is tracked in the pending mapping. The totals in this mapping are increased after each transfer request is created, and then reduced for each additional approval or rejection, all according to the specific parameters of each transfer request. Fixing the size of the array of IDs to this variable allows the loop to be exited, and the array returned, as soon as all of the relevant IDs have been found.
Requests that are currently pending will be located towards the end of the requests array, and so by iterating in reverse, more and more unnecessary iterations will potentially be avoided as the total number of instances stored in the requests array continues to increase over time.
Retrieving a smaller array of IDs in this way should end up being much more manageable than returning the whole array of Request instances, which will contain an ever-larger amount of unnecessary data.
Authorised signatories can only be changed by the contract creator at a time when there are no pending transfer requests. If this constraint wasn’t applied, some of the approvals recorded in the double mapping would no longer correspond to currently authorised signatories.
The total number of approvals required to send a transfer (2/3 or 3/3) is now recorded as a separate property within each Request instance, as well as the number of approvals still required. This is so that the total can be changed at any time, including when there are transfer requests pending. The new total will apply to all new transfer requests created after the change, whereas all requests that were pending at the time of the change will continue to require the same total number of approvals that were required at the time they were originally created.
ownable.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.7.5;
contract Ownable {
address public owner; // contract creator
modifier onlyOwner {
require(msg.sender == owner, "Operation restricted to contract creator");
_;
}
constructor() {
owner = msg.sender;
}
}
approval_B.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.7.5;
import "./ownable.sol";
contract Approval is Ownable {
// 3 signatories authorised to approve transfers, set by constructor
address[3] public auth;
// 2 or all 3 of the authorised signatories required to approve each transfer,
// set by constructor
uint8 public approvals;
// Records how many transfer requests are awaiting each authorised signatory's approval
mapping(address => uint8) pending;
event Approvals(uint8 required);
event SignatoryChanged(address removedAuth, address newAuth);
modifier onlyAuth {
require(
msg.sender == auth[0] || msg.sender == auth[1] || msg.sender == auth[2],
"Operation restricted to authorised signatories"
);
_;
}
constructor(uint8 _approvals, address _auth1, address _auth2, address _auth3) {
require(
_approvals == 2 || _approvals == 3,
"Required approvals must be 2 or 3 (out of 3)"
);
require(
_auth1 != _auth2 && _auth1 != _auth3 && _auth2 != _auth3,
"Each authorised signatory must be a different address"
);
approvals = _approvals;
auth[0] = _auth1;
auth[1] = _auth2;
auth[2] = _auth3;
}
function changeRequiredApprovals() external onlyOwner {
approvals == 3 ? approvals = 2 : approvals = 3;
emit Approvals(approvals);
}
function changeSignatory(uint8 authNum, address newAuth) external onlyOwner {
require(authNum >= 1 && authNum <= 3, "Select signatory 1, 2 or 3");
require(
pending[auth[0]] + pending[auth[1]] + pending[auth[2]] == 0,
"To replace an authorised signatory there must be no pending transfer requests"
);
require(
newAuth != auth[authNum - 1],
"New authorised signatory should be different from the one it is replacing"
);
require(
newAuth != auth[0] && newAuth != auth[1] && newAuth != auth[2],
"New authorised signatory must be different from the other two"
);
address priorAuth = auth[authNum - 1];
auth[authNum - 1] = newAuth;
emit SignatoryChanged(priorAuth, auth[authNum - 1]);
}
}
multisigWallet_B
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.7.5;
pragma abicoder v2;
import "./approval_B.sol";
contract MultisigWallet is Approval {
constructor(uint8 _approvals, address _auth1, address _auth2, address _auth3)
Approval(_approvals, _auth1, _auth2, _auth3) {}
struct Request {
uint id;
address beneficiary;
uint256 amount;
uint8 totalApprovals; /* Need to record total approvals required within
Request struct instance in case this is changed before transfer sent */
uint8 stillRequired; // Number of approvals still required
bool sent;
bool rejected;
address notSignedBy; /* Records signatory if they reject a transfer request but it
remains "Pending". This can only occur where 2 out of 3 approvals are required */
}
// Log of all transfers: pending, sent and rejected
Request[] private requests;
// Records which transfer requests have been approved by which authorised signatories
mapping(address => mapping(uint => bool)) private approvalTracker;
modifier IdValid(uint256 id) {
require(id != 0 && id <= requests.length, "Invalid ID");
_;
}
event Transfer(
string status, uint8 stillRequired, address auth, address beneficiary, uint256 amount
);
function getBalance() external view returns(uint256) {
return address(this).balance;
}
function getPending() external view onlyAuth returns(uint256) {
return pending[msg.sender];
}
function deposit() external payable {}
/* Any of the 3 authorised signatories can create a new transfer request and provide
1st approval, pending 1 or 2 further approvals from the other signatories.
(Note, no 1st approval is counted at this stage when the creator of the transfer
request is also the beneficiary, as explained in the introductory notes) */
function createRequest(address _beneficiary, uint256 _amount) external onlyAuth {
/* Check performed when transfer request created, in order to prevent
unreasonable transfer amounts being requested, and to prevent such
transfer requests from going through the approval process unnecessarily
and wasting storage in the requests array.
The transfer method will throw an error and revert the approveOrReject()
function if it eventually attempts to send a transfer when there is
insufficient contract balance to cover it. */
require(address(this).balance >= _amount, "Insufficient funds");
Request memory request;
request.id = requests.length + 1;
request.beneficiary = _beneficiary;
request.amount = _amount;
request.totalApprovals = approvals;
/* Helper function establishes the number of approvals
still required for this transfer to be sent */
request.stillRequired = _furtherApprovals(_beneficiary, request.totalApprovals);
requests.push(request);
approvalTracker[msg.sender][requests.length] = true;
/* Helper function adds 1 to the pending count of each authorised signatory
entitled to add their approval to this newly created transfer request */
_addPendingApproval(_beneficiary);
emit Transfer("Pending", request.stillRequired, msg.sender, _beneficiary, _amount);
}
/* Authorised signatories can retrieve an array of pending transfer
request IDs which they are entitled to approve or reject */
function forMyApproval() external view onlyAuth returns(uint256[] memory) {
uint256[] memory myIds = new uint256[](pending[msg.sender]);
uint8 counter;
for (uint256 i = requests.length - 1; counter != pending[msg.sender]; i--) {
if (
!requests[i].sent && !requests[i].rejected &&
requests[i].beneficiary != msg.sender &&
!approvalTracker[msg.sender][i+1]
) {
myIds[counter] = i + 1;
counter++;
}
}
return myIds;
}
/* Any address can get details of any transfer by its ID, and whether
transfer is pending, sent or rejected: RETURNS STRUCT INSTANCE */
function getTransfer(uint256 id) external view IdValid(id) returns(Request memory requestData) {
return requests[id-1];
}
/* Any address can get details of any transfer by its ID, and whether
transfer is pending, sent or rejected: RETURNS SEPARATE VALUES */
function getTransferDetails(uint256 id) external view IdValid(id) returns(
string memory status, address receiver, uint256 amount,
uint256 approvalsRequired, address rejectedBy
) {
Request memory request = requests[id-1];
string memory _status;
if (request.sent) _status = "Sent";
else if (request.rejected) _status = "Rejected";
else _status = "Pending";
return (
_status, request.beneficiary, request.amount,
request.stillRequired, request.notSignedBy
);
}
// Other authorised signatories approve or reject a pending transfer request
// Boolean parameter: true (approve/sign), false (reject/don't sign)
function approveOrReject(uint256 id, bool approve) external onlyAuth IdValid(id) {
Request storage request = requests[id-1];
require(!request.sent, "This transfer has already been sent");
require(!request.rejected, "This transfer request has already been rejected");
require(request.notSignedBy != msg.sender, "You have already rejected this transfer request");
address recipient = request.beneficiary;
require(
recipient != msg.sender,
"You cannot approve or reject this transfer request, because you are the beneficiary"
);
require(!approvalTracker[msg.sender][id], "You have already approved this transfer request");
if (
request.totalApprovals == 3 || approve || request.notSignedBy != address(0) ||
recipient == auth[0] || recipient == auth[1] || recipient == auth[2]
) {
request.stillRequired--;
}
pending[msg.sender] -= 1;
string memory status;
if (request.stillRequired == 0 && approve) {
approvalTracker[msg.sender][id] = true;
request.sent = true;
if (request.notSignedBy == address(0)) {
/* Helper function subtracts 1 from the pending count of each
authorised signatory who, due to the transfer now being sent,
is no longer entitled to add their approval to this request */
_removePendingApproval(id, recipient);
}
payable(recipient).transfer(request.amount);
status = "Sent";
}
else if (
request.stillRequired == 0 ||
request.stillRequired == 1 && !approve &&
(request.totalApprovals == 3 || approvalTracker[recipient][id])
) {
request.rejected = true;
request.stillRequired = 0;
if (request.notSignedBy == address(0)) {
/* Helper function subtracts 1 from the pending count of each
authorised signatory who, due to the transfer now being rejected,
is no longer entitled to add their approval to this request */
_removePendingApproval(id, recipient);
}
status = "Rejected";
}
else if (approve) {
approvalTracker[msg.sender][id] = true;
status = "Pending";
}
else {
request.notSignedBy = msg.sender;
status = "Rejected / Still Pending";
}
emit Transfer(status, request.stillRequired, msg.sender, recipient, request.amount);
}
/* Helper function adds 1 to the pending count of each authorised signatory
entitled to add their approval to a newly created transfer request */
function _addPendingApproval(address recipient) private {
for (uint8 i = 0; i <= 2; i++) {
if (msg.sender != auth[i] && recipient != auth[i]) {
pending[auth[i]] += 1;
}
}
}
/* Helper function subtracts 1 from the pending count of each authorised
signatory who, due to a transfer being either sent or rejected,
is no longer entitled to add their approval to the request */
function _removePendingApproval(uint256 id, address recipient) private {
for (uint8 i = 0; i <= 2; i++) {
if (
msg.sender != auth[i] && recipient != auth[i] &&
!approvalTracker[auth[i]][id]
) {
pending[auth[i]] -= 1;
}
}
}
// Establishes number of approvals still required to send a transfer
/* If 2/3 approvals required, and creator of new request is also
the beneficiary, then 2 further approvals still required */
/* If all 3 approvals required, but one of other 2 signatories is also the
beneficiary, then only 1 further approval required (i.e. total reduced to 2 */
function _furtherApprovals(
address recipient, uint8 totalApprovals
) private view returns(uint8) {
return totalApprovals == 2 && recipient != msg.sender ||
totalApprovals == 3 && recipient != msg.sender &&
(recipient == auth[0] || recipient == auth[1] || recipient == auth[2])
? 1 : 2;
}
}
Another version of the project, this time based on the template provided in the support video.
Additional functionality I’ve included, which isn’t in the template …
TransferData event, which is emitted when a new transfer request is created, and on each additional approval. The data logged by this event is:
(1) ID of transfer request
(2) Staus of transfer request: either Pending (if further approvals are required before it can be sent) or Sent
(3) Transfer amount
(4) Address of the beneficiary/receiver
(5) Owner address approving the transfer request
(6) Number of approvals still required before the limit is reached and the transfer can be sent (zero if the event is logging a sent transfer).
I have applied a minimum and maximum to the number of required approvals input as the _limit argument on deployment.
The minimum of 2 is to ensure that it is a multisig wallet.
The maximum = total owners - 1; this is to ensure an owner cannot approve a transfer if they are also the receiver. If the creator of a transfer request is also the receiver, then the transaction which creates such a request doesn’t count towards its number of approvals (as it does in other cases). Once created, an owner is prevented from adding their approval to any transfer request if they are also the receiver.
Having the min/max constraint on the number of required approvals means that there must also be a minimum of 3 owner addresses input within the _owners array argument on deployment, and each address must also be different, however many are input. No maximum number of owner addresses needs to be applied.
In order to check that each owner address is different, a helper function is used to iterate over the _owners array input into the constructor. A double loop is used so that a varying number of owner addresses can be checked.
Another helper function is called from within the require statement in the onlyOwners modifier. This helper function iterates over the array of owner addresses stored in the owners state variable. Iterating over the array enables an address calling a function to be compared with all of the owner addresses, however many there are, to ensure that it matches one of them.
getBalance function to retrieve the current contract balance. As the contract is a multisig wallet, the contract balance is the same as the wallet balance.
One disadvantage I can see with this particular solution is that if an owner decides not to approve a transfer request, then there is no option for them to explicitly reject it. This means that if two owners decide not to approve the same transfer request it will remain “Pending” indefinately; and this will also happen when only one owner decides not to approve a transfer request if the receiver is one of the other owners. My previous solution (in the post above) includes an option for an owner to register their rejection of a transfer request; and when such a rejection makes it impossible for a request to obtain the required number of approvals to be sent, the emitted event logs the transfer request as “Rejected”, and this definitive rejection is also recorded in the Boolean rejected property within the transfer request’s struct instance stored in the requests array.
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.7.5;
pragma abicoder v2;
contract Wallet {
address[] public owners;
uint limit;
struct Transfer {
uint id;
uint amount;
address payable receiver;
uint approvals;
bool hasBeenSent;
}
Transfer[] transferRequests;
mapping(address => mapping(uint => bool)) approvals;
event TransferData(
uint id, string status, uint amount, address receiver,
address ownerApproval, uint stillRequired
);
// Initializes the owners list and the approvals limit
constructor(address[] memory _owners, uint _limit) {
/* 1) Minimum approval limit = 2, to ensure wallet is multisig.
2) Maximum approval limit = total owners - 1, to allow an owner to
be prevented from adding their approval to a transfer if they are
also the receiver.
3) All owner addresses must be different to allow owners to be
prevented from approving the same transfer request more than once.
4) Therefore, there must be a minimum of 3 owner addresses,
but no maximum needs to be applied. */
require(_owners.length > 2, "There must be a minimum of 3 owners");
require(
_limit < _owners.length && _limit > 1,
"Required approvals: min = 2; max = total owners - 1"
);
// Calls helper function
require(_checkOwners(_owners), "Each owner must be a different address");
limit = _limit;
owners = _owners;
}
// Only allows people in the owners list to continue the execution.
modifier onlyOwners {
// Calls helper function
require(_isOwner(), "Operation restricted to owners");
_;
}
// Empty function
function deposit() public payable {}
/* Creates an instance of the Transfer struct and adds it to the
transferRequests array */
function createTransfer(
uint _amount, address payable _receiver
) public onlyOwners {
/* Check performed when transfer request created, in order to prevent
unreasonable transfer amounts being requested, and to prevent
such transfer requests from going through the approval process
unnecessarily and wasting storage in the transferRequests array.
The transfer method will throw an error and revert the approve()
function if it eventually attempts to send a transfer when there is
insufficient contract balance to cover it. */
require(address(this).balance >= _amount, "Insufficient funds");
Transfer memory request;
// The ID of a transfer request is based on its position in the array
request.id = transferRequests.length + 1;
request.amount = _amount;
request.receiver = _receiver;
/* If the creator of the request is also the receiver then their
approval doesn't count towards the total required (the limit) */
if (_receiver != msg.sender) request.approvals = 1;
transferRequests.push(request);
approvals[msg.sender][transferRequests.length] = true;
emit TransferData(
request.id, "Pending", request.amount, request.receiver,
msg.sender, limit - request.approvals
);
}
// An owner can approve one of the transfer requests (by its ID)
// The data recorded in the Transfer object (struct instance) is updated
function approve(uint _id) public onlyOwners {
require(_id != 0 && _id <= transferRequests.length, "Invalid ID");
Transfer storage request = transferRequests[_id - 1];
// An owner cannot approve a tranfer request that has already been sent.
require(!request.hasBeenSent, "This transfer has already been sent");
/* An owner cannot add their approval to a transfer request
if they are also the receiver */
require(
request.receiver != msg.sender,
"You're the receiver, so you cannot approve this transfer request"
);
// An owner cannot approve the same transfer request more than once
require(
!approvals[msg.sender][_id],
"You have already approved this transfer request"
);
request.approvals++;
string memory status;
/* When the number of approvals for a transfer has reached the limit,
the transfer is sent to the receiver */
if (request.approvals == limit) {
/* As the transfer is now being sent, there is no need to update
the mapping to record the approval */
// approvals[msg.sender][_id] = true;
request.hasBeenSent = true;
request.receiver.transfer(request.amount);
status = "Sent";
}
else {
/* If number of approvals hasn't reached limit yet, the mapping
needs to be updated to record the approval of msg.sender */
approvals[msg.sender][_id] = true;
status = "Pending";
}
emit TransferData(
_id, status, request.amount, request.receiver,
msg.sender, limit - request.approvals
);
}
// Returns all transfer requests
function getTransferRequests() public view returns(Transfer[] memory) {
return transferRequests;
}
function getBalance() public view returns(uint) {
return address(this).balance;
}
/*** HELPER FUNCTIONS ***/
// Iterates over array of owners to check that each is a different address
// Nested loop enables varying numbers of owners to be checked
function _checkOwners(address[] memory _owners) private pure returns(bool) {
for (uint i = 0; i < _owners.length - 1; i++) {
for (uint j = i + 1; j < _owners.length; j++) {
if (_owners[i] == _owners[j]) return false;
}
}
return true;
}
// Checks that the calling address is one of the owners
// Iterating over the array enables varying numbers of owners to be checked
function _isOwner() private view returns(bool) {
for (uint i = 0; i < owners.length; i++) {
if (msg.sender == owners[i]) return true;
}
return false;
}
}
My multisig wallet has 3 contracts: Ownable, RequestAndApprove and MultisigWallet.
Ownable and RequestAndApprove. It has a constructor which lets the wallet creator input the owners’ addresses and set the approval limit; the contract also has a couple of functions such as deposit, and get the balance of the wallet.allRequests (of the contract RequestAndApprove);State variable owners stores all information of owners, includes:
depositAmount: the amount of eth they have depositedisOwner: modifier onlyOwners uses this attribute to check if a sender is a owner or not// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
pragma abicoder v2;
contract Ownable {
struct Owner {
uint depositAmount;
bool isOwner;
}
mapping(address => Owner) internal owners;
modifier onlyOwners {
require(owners[msg.sender].isOwner,
"Only owners can run this function");
_;
}
function getOwner(address _ownerAddress)
public view returns(Owner memory) {
return owners[_ownerAddress];
}
}
Each request transfer includes:
requestId: because the wallet lets many requests exist at the same time, the requestId helps owners choose which request they want to approve first;All requests created will be stored in an array named allRequests.
State variable approvers keeps track of owners’ approval activities to make sure no one can approve any request more than 1 time.
A request only get approved by function approve(uint _requestId, address _approver) internal if:
MultisigWallet contract, that’s why this function has the modifier internal;request already checks to make sure every request created with the amount being less than or equal to the wallet balance, but because the wallet accepts multiple requests existed at the same time, so that there is a case where some requests get approved first spending the wallet balance to a point which makes the wallet balance is not sufficient to some other active requests anymore, so that’s why the approve() function should run this test again.// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
pragma abicoder v2;
contract RequestAndApprove {
struct Request {
uint requestId;
address requester;
address payable recipient;
uint amount;
string description;
uint voteCounts;
bool isActive;
}
Request[] public allRequests;
mapping(address => mapping(uint => bool)) internal approvers;
uint internal approvalLimit;
event requestCreated(uint requestId,
address requestor,
address recipient,
uint amount,
string description);
event approvalTriggered(address approver,
uint voteCounts,
bool isActive);
function _getBalance() private view returns(uint) {
return address(this).balance;
}
function request(address payable _recipient,
uint _amount,
string memory _description)
internal {
require(_amount <= _getBalance(),
"The amount you enter is too large");
uint id = allRequests.length;
_request(id, msg.sender, _recipient, _amount, _description);
emit requestCreated(id,
msg.sender,
_recipient,
_amount,
_description);
}
function _request(uint _requestId,
address _requestor,
address payable _recipient,
uint _amount,
string memory _description)
private {
Request memory newRequest = Request({
requestId: _requestId,
requester: _requestor,
recipient: _recipient,
amount: _amount,
description: _description,
voteCounts: 1,
isActive: true
});
approvers[_requestor][_requestId] = true;
allRequests.push(newRequest);
}
function approve(uint _requestId, address _approver) internal {
require(_requestId < allRequests.length,
"This request doesn't exist");
Request storage currentRequest = allRequests[_requestId];
require(currentRequest.isActive,
"This request is already completed");
require(!approvers[_approver][_requestId],
"You already vote for this request");
require(currentRequest.amount <= _getBalance(),
"The amount of this request is too large.");
_approve(_requestId, _approver);
emit approvalTriggered(msg.sender,
currentRequest.voteCounts,
currentRequest.isActive);
}
function _approve(uint _requestId, address _approver) private {
Request storage activeRequest = allRequests[_requestId];
activeRequest.voteCounts += 1;
approvers[_approver][_requestId] = true;
if (activeRequest.voteCounts >= approvalLimit) {
activeRequest.isActive = false;
activeRequest.recipient.transfer(activeRequest.amount);
}
}
}
The wallet creator can input an array of addresses to define the owners of the wallet.
In the constructor, the private function _convertOwnersArrayToMapping will map every address to an initial value (with the deposit amount starts with 0; and set isOwner to true, so the modifier onlyOwners (of the Ownable contract can tell which addresses are the owners of the wallet) :
Owner memory _owner = Owner({
depositAmount: 0,
isOwner: true
});
This contract also has a couple of functions: deposit() and getWalletBalance().
This contract inherits the request function, the approve function and the owners check from Ownable and RequestAndApprove.
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
pragma abicoder v2;
import "./Ownable.sol";
import "./Request_And_Approve.sol";
contract MultisigWallet is Ownable, RequestAndApprove {
event depositDone(address depositor, uint amount);
constructor(address[] memory _owners, uint _approvalLimit) {
require(_approvalLimit <= _owners.length,
"Approval limit is too large");
_convertOwnersArrayToMapping(_owners);
approvalLimit = _approvalLimit;
}
function _convertOwnersArrayToMapping(address[] memory _ownersArray)
private {
Owner memory _owner = Owner({
depositAmount: 0,
isOwner: true
});
for (uint i = 0; i < _ownersArray.length; i++) {
address ownerAddress = _ownersArray[i];
owners[ownerAddress] = _owner;
}
}
function deposit() public payable onlyOwners {
require(msg.value > 0,
"The amount you enter should be greater than 0");
owners[msg.sender].depositAmount += msg.value;
emit depositDone(msg.sender, msg.value);
}
function getWalletBalance()
public view returns(uint) {
return address(this).balance;
}
function requestTransfer(address payable _recipient,
uint _amount,
string memory _description)
public onlyOwners {
request(_recipient, _amount, _description);
}
function approveRequest(uint _requestId)
public onlyOwners {
approve(_requestId, msg.sender);
}
}
Great assignment. This is my first version.
Although I already have lots of ideas about how to improve it, this is the assignment it was demanded. I am planning to post new versions here soon.
// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.7.5;
pragma abicoder v2;
contract Wallet {
address[] public owners; // array of owners
uint approvalsLimit; // limit of approvals quantity
struct Transfer{
uint id;
uint amount;
address payable receiver;
uint approvals;
bool hasBeenSent;
}
Transfer[] transferRequests;
mapping(address => mapping(uint => bool)) approvals;
modifier onlyOwners {
bool isOwner = false;
for (uint i = 0; i < owners.length; i++){
if (owners[i] == msg.sender) {
isOwner = true;
break;
}
}
require(isOwner == true);
_; //run function
}
event DepositDone(address owner, uint amount);
event TransferRequestCreated(uint _id, uint _amount, address _initiator, address _receiver);
event ApprovalReceived(uint _id, uint _approvals, address _approver);
event TransferApproved(uint _id);
constructor(address[] memory _owners, uint _approvalsLimit) {
require( _approvalsLimit <= _owners.length, "Error: approvals limit is greater than owners quantity.");
owners = _owners;
approvalsLimit = _approvalsLimit;
}
//Create an instance of the Transfer struct and add it to the transferRequests array
function createTransfer(uint _amount, address payable _receiver) public onlyOwners {
require(address(this).balance >= _amount, "Error: insufficient funds.");
transferRequests.push ( Transfer( transferRequests.length, _amount, _receiver, 0, false) );
emit TransferRequestCreated(transferRequests.length, _amount, msg.sender, _receiver);
}
// Approves and sent the transfer if reached the limit
function approve(uint _id) public onlyOwners {
require(approvals[msg.sender][_id] == false, "Error: owner already voted.");
require(transferRequests[_id].hasBeenSent == false, "Error: transfer has already been sent.");
require(address(this).balance >= transferRequests[_id].amount, "Error: insufficient funds.");
approvals[msg.sender][_id] == true;
transferRequests[_id].approvals++;
emit ApprovalReceived(_id, transferRequests[_id].approvals, msg.sender);
if ( transferRequests[_id].approvals >= approvalsLimit){
transferRequests[_id].hasBeenSent == true;
transferRequests[_id].receiver.transfer(transferRequests[_id].amount);
emit TransferApproved(_id);
}
}
//Return all transfer requests
function getTransferRequests() public view returns (Transfer[] memory){
return transferRequests;
}
// Deposit
function deposit() public payable {
emit DepositDone(msg.sender, msg.value);
}
// Get contract balance
function getBalance() public view returns(uint) {
return address(this).balance;
}
function selfDestroy() public onlyOwners {
selfdestruct(msg.sender);
}
}
The following is my answer.
pragma solidity 0.7.5;
pragma abicoder v2;
contract MSWallet{
address private owner;
address private owner2;
address private owner3;
uint private appReq;
event depositMade(uint amount, address depositor);
event transferInitiated(address from, address to, uint amount, uint txID);
event transferApproved(uint txID, address approver);
event transferExecuted(address from, address to, uint amount, uint txID);
modifier onlyOwner {
require(msg.sender == owner || msg.sender == owner2 || msg.sender == owner3, "Address does not have admin access");
_; // This underscore basically means "continue with running function"
}
constructor(address _owner2, address _owner3, uint _approval_Requirement) {
require(msg.sender != _owner2 && msg.sender != _owner3 && _owner2 != _owner3, "Duplicate owner addresses");
require(_approval_Requirement <= 3, "Approval requirement <= 3");
owner = msg.sender;
owner2 = _owner2;
owner3 = _owner3;
appReq = _approval_Requirement;
}
struct fundTransfer {
address from;
address payable to;
uint amount;
uint txId;
uint approvals;
address[3] approvalLog;
bool isApproved;
}
fundTransfer[] fundTransferLog;
function deposit() public payable {
emit depositMade(msg.value, msg.sender);
}
function walletBalance() public view returns(uint) {
return address(this).balance;
}
function initiateFundTransfer(uint _amount, address payable _recipient) public onlyOwner {
require(address(this).balance >= _amount, "Insufficient Balance");
address[3] memory _approvalLog;
_approvalLog[0] = msg.sender;
if (appReq > 1){
emit transferInitiated(msg.sender, _recipient, _amount,fundTransferLog.length);
fundTransferLog.push(fundTransfer(msg.sender, _recipient, _amount, fundTransferLog.length, 1, _approvalLog, false));
} else {
fundTransferLog.push(fundTransfer(msg.sender, _recipient, _amount, fundTransferLog.length, 1, _approvalLog, true));
emit transferApproved(fundTransferLog.length, msg.sender);
_sendFunds(_amount, _recipient);
emit transferExecuted(msg.sender, _recipient, _amount, fundTransferLog.length);
}
}
function approveFundTransfer(uint _txID) public onlyOwner {
require(address(this).balance >= fundTransferLog[_txID].amount, "Insufficient balance.");
require(fundTransferLog[_txID].isApproved != true, "Transaction has already been executed.");
//Check if owner has already approved transaction.
uint check = 0;
for (uint i = 0; i < fundTransferLog[_txID].approvalLog.length; i ++){
if (msg.sender == fundTransferLog[_txID].approvalLog[i]) {
check ++;
}
}
require(check == 0, "Owner has already approved transaction.");
fundTransferLog[_txID].approvals += 1;
uint appIndex = fundTransferLog[_txID].approvals - 1;
fundTransferLog[_txID].approvalLog[appIndex] = msg.sender;
emit transferApproved(_txID, msg.sender);
if (fundTransferLog[_txID].approvals >= appReq) {
fundTransferLog[_txID].isApproved = true;
_sendFunds(fundTransferLog[_txID].amount, fundTransferLog[_txID].to);
emit transferExecuted(fundTransferLog[_txID].from, fundTransferLog[_txID].to, fundTransferLog[_txID].amount, _txID);
}
}
function _sendFunds(uint _amount, address payable _recipient) private returns (uint){
_recipient.transfer(_amount);
return address(this).balance;
}
function getTransaction(uint _txID) public view returns(fundTransfer memory) {
return fundTransferLog[_txID];
}
}
// SPDX-License-Identifier: MIT
pragma solidity >= 0.7.0 < 0.9.0;
pragma abicoder v2;
contract Wallet {
address[] public owners;
uint limit;
struct Transfer{
uint amount;
address payable receiver;
uint approvals;
bool hasBeenSent;
uint id;
}
Transfer[] transferRequests;
mapping(address => mapping(uint => bool)) approvals;
//Should only allow people in the owners list to continue the execution. ✅
modifier onlyOwners(){
bool owner = false;
for(uint i = 0; i < owners.length; i++){
if(msg.sender == owners[i]){
owner = true;
}
}
require(owner, "Access Denied");
_;
}
//Should initialize the owners list and the limit ✅
constructor(address[] memory _owners, uint _limit) {
owners = _owners;
limit = _limit;
}
//Empty function ✅
function deposit() public payable {}
//Create an instance of the Transfer struct and add it to the transferRequests array ✅
function createTransfer(uint _amount, address payable _receiver) public onlyOwners {
Transfer memory transferRequest = Transfer(_amount, _receiver, 0, false, transferRequests.length);
transferRequests.push(transferRequest);
}
//Set your approval for one of the transfer requests. ✅
//Need to update the Transfer object. ✅
//Need to update the mapping to record the approval for the msg.sender. ✅
//When the amount of approvals for a transfer has reached the limit, this function should send the transfer to the recipient. ✅
//An owner should not be able to vote twice. ✅
//An owner should not be able to vote on a tranfer request that has already been sent. ✅
function approve(uint _id) public onlyOwners {
require(!transferRequests[_id].hasBeenSent, "Transfer already approved");
require(!approvals[msg.sender][_id], "Cannot vote twice");
transferRequests[_id].approvals++;
approvals[msg.sender][_id] = true;
if(transferRequests[_id].approvals == limit){
transferRequests[_id].receiver.transfer(transferRequests[_id].amount);
transferRequests[_id].hasBeenSent = true;
}
}
//Should return all transfer requests
function getTransferRequests() public view returns (Transfer[] memory){
return transferRequests;
}
}
so i kinda made something that goes along the lines of a smart contract that allows users to deposit with multiple signatories, allowing the user to choose how many other signatories are required to, allowing the owner and any of the signatories to request for transfer, allowing owner or signatories to approve the request until the minimum signatures are required before transfer occurs. Here is my very un-optimized code that’s also available on my GitHub: https://github.com/KKCheah/MultiSigWallet_Ethereum/blob/main/multisig_prototype.sol
pragma solidity 0.7.5;
pragma abicoder v2;
contract MultiSigWallet{
//mapping
mapping(address => mapping(uint => uint))depositID;
mapping(address => mapping(uint => uint))balance;
mapping(address => mapping(uint => address))depositOwner;
mapping(address => mapping(uint => mapping(uint => uint)))WithdrawSettingID;
mapping(address => mapping(uint => mapping(uint => uint)))TransferRequestID;
//state variables?
address[] walletOwners;
address payable[] clearToAdd;
address payable[] adr;
address[] toAdd;
bool[] toFalse;
uint fillerInt = 0;
//structs
//struct to keep deposit records
struct depositRecord {
uint txnId;
address depositOwner;
uint numberOfOwners;
uint numberOfApprovalsForTransfer;
uint valueOfDeposit;
}
depositRecord[] InitialDeposit;
//struct for setting transfer permission
struct transferPermission {
uint depositId;
address[] depositUsers;
bool[] withdrawStatus;
uint minNoOfApproval;
uint WithdrawSettingID;
bool settingComplete;
}
transferPermission[] transferPermissionSetting;
//struct for storing transfer information
struct withdrawalInfo {
address userRequesting;
uint depositID;
uint WithdrawSettingID;
uint TransferingNo;
uint transferValue;
address toTransfer;
bool finalApproval;
}
withdrawalInfo[] withdrawalInformation;
//event
event SuccessfulTransfer(uint indexed value, address indexed recipient, uint indexed tranferRequestNo);
//function to deposit Ether into this contract
function depositEtherToContract(uint _totalOwners, uint _approvalsForTransfer) public payable returns (string memory, uint){
require(msg.value > 0, "There is no Ether being deposited");
assert(msg.value > 0);
uint depositIndex = InitialDeposit.length;
uint depositTxnID = InitialDeposit.length;
InitialDeposit.push(depositRecord(depositID[msg.sender][depositIndex], msg.sender, _totalOwners, _approvalsForTransfer, msg.value));
depositOwner[msg.sender][depositTxnID] = msg.sender;
balance[msg.sender][depositTxnID] = msg.value;
depositID[msg.sender][depositTxnID] = depositTxnID;
return ("Deposit success, please key in deposit transaction ID in the future to check deposit. Your Txn ID is", depositTxnID);
}
//function to check the deposit using the Txn ID
function findDeposit(uint _txnId) public view returns (depositRecord memory) {
uint depositNumber = depositID[msg.sender][_txnId];
require (depositNumber >= 0, "You've key in an invalid number aka wrong transaction ID etc");
return InitialDeposit[depositNumber];
}
//function to assign owner and subowner for specific deposit
function assignSubOwners(uint _txnId, address _subOwner)public returns (string memory, uint){
uint depositNumber = depositID[msg.sender][_txnId];
uint depositIndexAssign = depositNumber; //index starts at zero but content with length starts at 1
uint noShareOwners = InitialDeposit[depositIndexAssign].numberOfOwners;
uint _minNoOfApproval = InitialDeposit[depositIndexAssign].numberOfApprovalsForTransfer;
require (msg.sender == InitialDeposit[depositIndexAssign].depositOwner);
if (noShareOwners > toAdd.length){
toAdd.push(_subOwner);
toFalse.push(false);
}
if (noShareOwners == toAdd.length) {
uint transferSetupID = transferPermissionSetting.length;
uint transferNumber = transferPermissionSetting.length;
transferPermissionSetting.push(transferPermission(depositNumber, toAdd, toFalse, _minNoOfApproval, transferSetupID, true));
WithdrawSettingID[msg.sender][_txnId][transferSetupID] = transferNumber;
delete toAdd;
delete toFalse;
return ("A address has been added to approve withdrawals, All subOwners Filled. Your transfer Request ID is", transferSetupID) ;
}
return ("A address has been added to approve withdrawals", fillerInt);
}
//function to check status of withdrawal permission of specific depositNumber
function checkPermissionSetting(uint _txnId, uint _transferSetupID)public view returns (transferPermission memory){
uint transferNumber = WithdrawSettingID[msg.sender][_txnId][_transferSetupID];
uint transferIndex = transferNumber;
return transferPermissionSetting[transferIndex];
}
//function to request for withdrawal from any of the owner/subOwners
function requestForTransfer(uint _depositID, uint _transferSetupID, address _mainOwner, uint _transferValue, address _recipient) public returns (string memory, uint){
uint transferNumber = withdrawalInformation.length;
uint requestNumber = WithdrawSettingID[_mainOwner][_depositID][_transferSetupID];
bool scanStatus = false;
uint requestIndex = requestNumber;
for (uint i = 0; transferPermissionSetting[requestNumber].depositUsers.length >= i; i++){
if (transferPermissionSetting[requestNumber].depositUsers[i] == msg.sender){
scanStatus = true;
transferPermissionSetting[requestNumber].withdrawStatus[i] = true;
TransferRequestID[msg.sender][requestNumber][withdrawalInformation.length] = transferNumber;
require(InitialDeposit[_depositID].valueOfDeposit >= _transferValue, "Insufficient funds to perform transfer");
withdrawalInformation.push(withdrawalInfo(msg.sender, _depositID, requestIndex, transferNumber, _transferValue, _recipient, false));
assert(InitialDeposit[_depositID].valueOfDeposit >= _transferValue);
return ("Request accepted and pending, you transfer number is", transferNumber) ;
}
}
if (scanStatus == false){
return ("You are not verified for the transaction stated, please key in deposit and transfer setting ID again, error code", 1);
}
return ("You're not supposed to reach here, error code:", 2);
}
function check(uint _transferNo) public view returns(withdrawalInfo memory){
return withdrawalInformation[_transferNo];
}
function approveRequestForTransfer(address _requestUser, uint _transferNo) public returns (address, string memory) {
if (withdrawalInformation[_transferNo].userRequesting == _requestUser){
bool scanStatus = false;
uint countApproval = 0;
uint value = withdrawalInformation[_transferNo].WithdrawSettingID;
uint arrayLength = transferPermissionSetting[value].depositUsers.length;
for (uint z = 0; arrayLength >= z; z++){
if (transferPermissionSetting[value].depositUsers[z] == msg.sender){
scanStatus = true;
transferPermissionSetting[value].withdrawStatus[z] = true;
for (uint y = 0; transferPermissionSetting[value].withdrawStatus.length >= y; y++){
if (transferPermissionSetting[value].withdrawStatus[y] = true) {
countApproval++;
if(countApproval>=transferPermissionSetting[value].minNoOfApproval){
require (transferPermissionSetting[value].depositId == InitialDeposit[value].txnId, "Error at the comparison");
balanceTranfer(_transferNo, withdrawalInformation[_transferNo].transferValue);
resetWithdrawStatus(_transferNo);
return (msg.sender, "Congratulation");
}
}
}
return (msg.sender, "Approved");
}
}
return (msg.sender, "Failed 1");
}
return (msg.sender, "Failed 2");
}
function balanceTranfer(uint _transferNo, uint _valueOfTransfer ) private returns (string memory, address, string memory, uint){
withdrawalInformation[_transferNo].finalApproval = true;
payable(withdrawalInformation[_transferNo].toTransfer).transfer(_valueOfTransfer);
InitialDeposit[withdrawalInformation[_transferNo].depositID].valueOfDeposit -= _valueOfTransfer;
emit SuccessfulTransfer(_valueOfTransfer, withdrawalInformation[_transferNo].toTransfer, _transferNo);
return ("transferred to address: ", withdrawalInformation[_transferNo].toTransfer, " with a value of: ", _valueOfTransfer);
}
function resetWithdrawStatus(uint _transferNo) private {
for (uint i = 0; transferPermissionSetting[withdrawalInformation[_transferNo].WithdrawSettingID].withdrawStatus.length <= i; i++){
transferPermissionSetting[withdrawalInformation[_transferNo].WithdrawSettingID].withdrawStatus[i] = false;
}
}
}
Does Truffle have a “pager” (I couldn’t find anything using google). That is, if I display something and it’s larger than a page, is there a way to have it pause a screenful at a time? Like more? or less?
P.S. one solution is for me to use a terminal app that lets me scroll text that has gone off screen. I’m used to using tmux or screen where the scrolling is bit clumsy. I can work around that.