When is hashing used when creating a smart contract?

Question

I was going through the solidity docs and in a contract example given I have seen keccak256 used.

// Perform checks to determine if transferring a token to the
// `OwnedToken` contract should proceed
function isTokenTransferOK(address currentOwner, address newOwner)
    public
    pure
    returns (bool ok)
{
    // Check an arbitrary condition to see if transfer should proceed
    return keccak256(abi.encodePacked(currentOwner, newOwner))[0] == 0x7f;
}

From this video I was able to understand that:

A hash function is a function that takes in an arbitrary size input and outputs data of fixed size.

I also understood that keccak is a hash function.

When is hashing used when creating a smart contract? What is its purpose? An example would really help me understand.

Answer 1

IMHO, it's not a terrific example for teaching.

Hash functions are very useful for validating information and they are used to prove things with Smart Contracts as well as on the blockchain itself. For example, block transactions are hashed which is a sort of fingerprint for authentic blocks. Previous blockhashes are part of that functions, so it forms a chain.

This will not be an academic description but it will give you a working knowledge of this tool.

Properties of a Hash function:

1. Deterministic: For any given input, the output is always the same.
2. Fixed Size: e.g. 32 bytes
3. Uncorrelated: If even a single bit of the input is changed, the output in completely changed in an unpredictable way
4. Collision-resistant: No two inputs should produce the same output, a "defect" known as a hash collision.
5. High-performant: The compute resources to the compute the hash should be reasonable.
6. One-way function: A hash tells one nothing about the size, format or content of the input.

Hashes are commonly used to store passwords on disks because hashes tell one nothing about the passwords, but user-inputted passwords can be quickly hashed and then compared to a table.

They are also commonly used to validate documents/files by storing only the hash of the files in a system of record such as a Smart Contract. Given that record, anyone can confirm that the file they have matches a previously-recorded hash - it must be the same file.

Here's a way to put money in a box and let it be released if someone knows a secret word.

pragma solidity 0.7.6;
contract Abracadabra {
bytes32 public publicHash;

constructor(bytes32 publicHash_) {
    publicHash = publicHash_;
}

function honeyPot(bytes32 password) public {

    // a little concatonation, then hash it
    // it can only be claimed by the intended recipient

    bytes32 hash = keccak256(abi.encodePacked(password, msg.sender));

    // no one knows the password unless they learn about it off-chain
    // revert the transaction if the hash is wrong

    require(hash == publicHash, "That's not the magic word");

    // the money only goes to msg.sender to prevent front-running

    msg.sender.transfer(address(this).balance);
}

receive () external payable {}

}

Notice that the hash is on the chain from the outset, but it doesn't help anyone figure out the password. The contract naively stored a password instead of a hash, then everyone would see the password and that would be bad. There's certainly more to think about if securing such a thing but I want to keep this answer on point.

You need to be able to make the hash when you deploy it. This is not safe from a security standpoint, but it should be possible to play with it in Remix.

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.7.6;
contract Abracadabra {
bytes32 public publicHash;

constructor(bytes32 publicHash_) {
    publicHash = publicHash_;
}

function honeyPot(bytes32 password) public {   
    require(hashHelper(password, msg.sender) == publicHash, "That's not the magic word");
    msg.sender.transfer(address(this).balance);
}

function hashHelper(bytes32 password, address receiver) public pure returns(bytes32 hash) {
    hash = keccak256(abi.encodePacked(password, receiver));        
}

receive () external payable {}

}

Hope it helps.