Ethereum: Multisig vs Multi-Input Transaction Signing
Ethereum smart contracts are designed to run on a decentralized network of nodes, requiring secure and trusted interactions between parties. One of the most important aspects of these transactions is the signing process, which involves verifying the identity and integrity of the sender. In this article, we will examine the differences between multisig and multi-input transaction signing in Ethereum.
Multisig vs Multi-Input Transaction Signing: A Comparison
Imagine that you are planning a multi-day camping trip with your friends. To ensure that everyone follows the same rules, you need to define a set of checks that need to be performed before leaving campsite A. You have two sets of permissions: “A” and “B,” which correspond to different campsites.
Multisig Transaction Signing
With multisig transactions, multiple accounts (called “signers”) are required to sign a transaction. Each signer has a unique private key that must be verified before the transaction can be completed. To ensure security, each signer must have at least one input to the transaction that allows them to spend funds from their balance. In our camping example, you will need two signatures from different signers (A and B) to confirm that they both agree to the camping rules.
Here is a simple Solidity code snippet:
pragma solidity ^0,8,0;
contract MultiSig {
mapping(address => uint256) public balances;
mapping(address => bool) public signerState;
function deposit(uint256 amount) public {
Require(balances[msg.sender] < amount, "Insufficient balance");
balances[message sender] += amount;
}
function withdraw(uint256 amount) public {
Request(signerStatus[msg.sender], "Signer not verified");
Request(balances[msg.sender] >= amount, "Insufficient funds");
// Send the amount back to the sender
uint256 txValue = 1 ether;
payable(message sender).transfer(txValue);
balances[message sender] -= txValue;
}
}
In this example, we define the «deposit» and «withdraw» functions that require multiple signatures from different signatories. The «signerStatus» binding ensures that each signatory is verified before allowing the funds to be withdrawn.
Signing Multiple Input Transactions
Now let’s look at an example where the transaction has two inputs: «inputA» and «inputB». We want this input to be signed with at least one private key from different signatories.
Here is a snippet of Solidity code:
pragma solidity ^0,8,0;
contract MultiInput {
mapping(address => uint256) public balances;
mapping(address => bool) public signerStatus;
function inputA(uint256 value) public payable {
Require(balances[msg.sender] < 1 ether, "Insufficient balance");
balances[messagesender] += value;
}
function inputB(uint256 value) public payable {
Require(signerStatus[msg.sender], "Signer not verified");
Require(balances[msg.sender] >= 100 ether, "Insufficient funds");
// Send the amount to the contract
uint256 txValue = 1 ether;
payable(this).transfer(txValue);
}
function withdraw(uint256 amount) public {
Claim(signerStatus[msg.sender], "Signer not verified");
Claim(balances[msg.sender] >= amount, "Insufficient funds");
// Send the amount back to the sender
uint256 txValue = 1 ether;
payable(message sender).transfer(txValue);
balances[message sender] -= txValue;
}
}
In this example, we define two functions: «inputA» and «inputB». Each function requires a signature from at least one private key. The «Withdraw» function allows you to transfer funds to other accounts.