Willidity: Reference Guide

About

Presenting Willidity, a prototype Web3 application for decentralized Will creation and deployment with Solidity. You can deploy wills at a time of your choice, while the will is kept secret before that.

Usage directions:

• LC shall create a pair of RSA keys. The private key must be in pkcs8 format. Same for CC
• Deploy the Will Factory script written below on an Ethereum testnet (e.g Sepolia)
• Before Deploying, the owner must set their own address in the script
• Owner must have access to public keys of LC and CC
• Send the Will Factory sufficient testETH as per the requirements of the will logic
• Before pressing ‘Connect Wallet’, the owner/executor must paste the Will Factory Address in the designated field
• Also note, visit this site only from a browser that supports crypto wallets as browser extensions and also ensure that you have installed the same.
  Ensure your wallet is unlocked for it to interact with the site.
• Then, the owner sets the contract threshold time.
  This is the minimum amount of time that needs to elapse before the CID is disclosed and subsequent steps are executed
• Paste the source of their Will Smart Contract and compile it
• The bytecode resulting from the compilation is displayed
• Press ‘Decrypt, Upload to IPFS…’
• Resetting the contract state to the start can be done by the Reset Button
• Owner can also withdraw funds from the contract with ‘withdraw’

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

contract WillFactory {

    constructor() payable {
         // receive ETH at deployment
    }


    event Deployed(address addr);
    event Hashed(string hash);

    uint256 private thresholdTime=block.timestamp+3 minutes;

    bytes32 private bytecodecheck;

    bytes32 private cidcheck;

    bytes private encryptedCID;

    string public CID="";

    bool commit=false;

    bool locDisclosed=false;

    //TODO: Change address!
    address constant owner=0xC1...;

    modifier onlyOwner() {
        require(msg.sender == owner, "Caller is not the owner");
        _; // Placeholder for the modified function's logic
    }


    function deployBytecode(bytes memory bytecode) external returns (address addr) {
        bytes32 bHash = keccak256(bytecode);
        require(bytecode.length > 0, "Bytecode is empty");
        //require(block.timestamp > thresholdTime, "too early");
        require(locDisclosed, "too early. Did you hack?");
        require(bHash==bytecodecheck, "Do not decieve");

        uint256 startGas = gasleft();
        assembly {
            // create(value, offset, size)
            // value = 0 (no ETH sent)
            // offset = pointer to bytecode data in memory
            // size = length of bytecode
            addr := create(11000000000000000, add(bytecode, 0x20), mload(bytecode))
        }
        if (addr == address(0)) {
        // Possible reasons: revert in constructor, out of gas, invalid bytecode
        uint256 gasUsed = startGas - gasleft();
        revert(
            string(
                abi.encodePacked(
                    "Deployment failed (constructor revert / invalid bytecode / out of gas). Gas used: ", gasUsed
                )
            )
        );
    }
        _reset();
        emit Deployed(addr);
    }


    function bytesToBytes32(bytes memory b) private pure returns (bytes32) {
  bytes32 out;

  for (uint i = 0; i < 32; i++) {
    out |= bytes32(b[ i] & 0xFF) >> (i * 8);
  }
  return out;
}

    function setEncryptedCID(bytes calldata ec, bytes calldata hcid) external onlyOwner{
        encryptedCID = ec;
        cidcheck = bytesToBytes32(hcid);
    }

    function setBytecodeHash(bytes calldata bs) external onlyOwner{
        require(!commit, "can Only set once");
        bytecodecheck = bytesToBytes32(bs);
        commit=true;
    }

    function setThresholdTime(uint256 Seconds) external onlyOwner{
        thresholdTime=block.timestamp+Seconds;
    }

    function getECID() external view returns (bytes memory) {
        return encryptedCID;
    }

    function setCID(string calldata ciid) external {
        require(block.timestamp > thresholdTime, "too early");
        bytes32 chash=keccak256(abi.encodePacked(ciid));
        require(chash==cidcheck, "authentic CID already set");
        CID=ciid;
        locDisclosed=true;
    }

    function deposit() public payable {
            // The ether is sent to the contract here
            // You can add other logic here, for example, updating a user's balance
    }

    function withdraw() public payable onlyOwner{
            // The ether is sent to the contract here
            // You can add other logic here, for example, updating a user's balance
            address payable op = payable(owner);
            op.transfer(address(this).balance-0.0004 ether);
    }

    function reset()  external onlyOwner {
        _reset();
        
    }

    function _reset() internal 
    {
        CID="";
        commit=false;
        encryptedCID="";
        bytecodecheck=bytes32(0);
        locDisclosed=false;
    }
}
      

Deployment Flow: Owner encrypts bytecode and puts it on IPFS, Sets parameters on WF contract

Deployment Flow: Custodians disclose CID and deploy Bytecode

Terminologies

• Owner: The owner is the entity that has some amount of ETH, and wishes it is distributed in a certain way after a certain time according to a logic which they desire.
  This logic is coded in a Solidity Contract known as a ‘will’. The ether which shall be distributed is entrusted to the will factory.
• Will Factory: The Will Factory is a smart contract that is responsible for deploying the will contract,
  passing on the entrusted ether to the deployed will, and maintaining integrity throughout the process.
  It ensures that the execution of the will is only carried out after the threshold time has elapsed set by the owner.
• Executor/Custodian: The owner entrusts the execution of the will to two trusted entities (executors).
  One is the Location Custodian (LC) and the other known as the Content Custodian (CC).
  The owner encrypts the CID of the IPFS upload with the LC public key. And encrypts the bytecode of the will contract with the public key of the CC.
  Afterwards, the WF returns the address of the deployed will.

Security and Integrity measures:

Everything on the contract is visible publicly, even private variables. So, its necessary all cryptography happens off chain.

Also, the responsibility of execution has been split between two members to ensure that incase one of them behaves with vested intentions, either the content or the location (CID) is kept secret. The hash of the bytecode ensures that only the bytecode written by the owner is deployed.

Also, the bytecode being encrypted plays a peculiar role. By keeping the will logic secret, it ensures that no party behaves/creates influence via specific behaviours before the execution of the will, so that the will logic favours them.

The reason for resorting to blockchain is to ensure integrity, transparency, accountability and that no one party has full control of the entire process.