SHITLIST — A timely experiment in Social Governance.

Edit for clarity: SHITLIST is a dApp for the #metoo movement. Powered by Ethereum it allows victims of sexual assault, abuse or harassment to name their abusers/harassers. It has a novel form of solidity powered governance to simultaneously protect against abuse of the system, protect victims from being silenced and, ironically, protect the privacy of non-public persons who are being accused.

An Ethereum powered version of the Shitty men in Media List.

Last night I presented at the CryptoNYC and EdCon dApp Pitch Fest, hosted by Airswap, a new project I have developed called SHITLIST.

Shitlist is an experiment in decentralized justice and governance built on Ethereum. It is a decentralized application- meaning once launched it operates independently of any centralized party. It is autonomous and ownerless. The application layer is run on Ethereum, while the data storage is all hosted on IPFS. No centralized servers. Nothing to shut down, sue, extort or otherwise.

Shitlist currently works like this: Victims can submit names to the list anonymously, but to do so they must put up a stake- some amount of Ether denominated money which is eventually returned. The stake requirement is necessary to dissuade casual abuse of the system. There are no mechanisms to validate the veracity of a claim (an impossible task for an algorithm) so there needs to be way, unfortunately, to require individuals to put up something of value when making a claim. It is import to recognize however that this money is not lost- it is eventually returned to the person who contributes it after a longer period of time, so the system in net costs nothing to use.

When making a claim, a victim can submit a name, description, and an image (screenshot of evidence for example)- all this data is stored on the blockchain and IPFS.

To check a name, one enters a name and the EVM returns a hash location on IPFS which is loaded as text and image.

After a (yet to be determined) period of time goes by, the person who made the claim is able to request a refund of the money which is returned automatically by the smart contract to the original claimants ethereum wallet.

The goal of Shitlist addresses an issue of personal importance: Sexual Violence in the fashion industry. My background is as a fashion photographer for the past 15 years and the recent reckoning my industry has been going through has served as a wakeup call to our own complicity in cycles of abuse and negligence.

Cameron Russel among others (James Scully, thank you) have really made it possible to speak up.

Being involved in the crypto ecosystem it occurred to me that we have an opportunity to really leverage the power of decentralized applications and blockchain to start addressing the issues of decentralized governance in a way that really impacts the lives of people.

When ShitModelManagement posted their infamous BLACKLIST the backlash was swift and fierce. Privately models and photographers poured over the list picking out the names we knew personally, and the rumors we knew personally. In my personal conversations with models over the list the resounding answer was “finally” and “of course”. Not a week went by before the threats of violence and intimidation became too great.

Shitmodelmgmt is pressured to take down the black list.

Of course all this follows in the footsteps of the Shitty Men in Media List which was started by Moira Donegan (albeit anonymously at the beginning) as a shared google spreadsheet where women in the media industry could list names of men that women felt were dangerous, had victimized women and were dangerous to other women.

This list contributed to the national reckoning of the #metoo movement, where women were coming forward to point out their abusers. Besides ShitModelmgnt’s list, there also exists numerous underground collections of names shared by models through instagram pages, model forums and word of mouth as a collective form of self defense. (Not to overlook the men who are also victimized.

Shitlist then is an experiment in creating a blockchain powered version of these lists that allow individuals to contribute anonymously but at the same time, through decentralization, creates a structure that is unassailable. In a successful public deployment there is no one to threaten, sue or censor. The application runs itself.

Some improvements to the software that I’ve already been considering are:

• Group Staking — individuals can increase the stake of specific claims by staking larger sums on particular claims.
• Donations — Instead of money being returned it can be directed towards charities.
• Portal for Victim support and general education.
• Rate-limiting to limit “Flood abuse”.
• Enhanced browser side encryption.
• Open “API” format allowing people to plug into the standardized data in IPFS to create local language versions.
• Pyramid Staking scheme for individuals that can’t afford the stake, or to deter abuse where initial claims require little or no stake, but where follow on claims become either increasingly more expensive, or require increasingly more time before being added to the list.

Shitlist is Open Source.

Dennison Bertram — MIT License 2018

GitHub: https://github.com/crazyrabbitLTC/ShitList

Questions?

dennison@dennisonbertram.com

pragma solidity ^0.4.21;
//Created by Dennison Bertram 2018
//Open Source as per MIT License.
contract Shitlist{
//mapping of times a Name is found
mapping(string => uint) countevents;
//mapping of name to mapping of case number to string of IPFS - Text Details
mapping(string => mapping(uint => string)) database;
//mapping of name to mapping of case number to image file for evidence.
mapping(string => mapping(uint => string)) imageFiles;
struct Victim {
address person;
uint stake;
uint time;
}
//mapping of victim to accused to amount staked and when
mapping(address => mapping(string =>Victim)) victimDatabase;
uint RefundTime;
uint MinimumStake;
function Shitlist(uint _refundtime, uint _minimumStake) public {
RefundTime = _refundtime;
MinimumStake = _minimumStake;
}
function makeClaim(string _name, string _ipfs, string _ipfsImage) payable public {
//many things to check- how many claims they make, did they make a claim before, etc...
countevents[_name] += 1;
database[_name][countevents[_name]] = _ipfs;
imageFiles[_name][countevents[_name]] = _ipfsImage;
victimDatabase[msg.sender][_name].person = msg.sender;
victimDatabase[msg.sender][_name].stake = msg.value;
victimDatabase[msg.sender][_name].time = block.timestamp;
}
function checkClaimExists(string _name) view public returns(uint){
//later they should check only 12 hours
if(countevents[_name] == 0)
return(0);
else
return(countevents[_name]);
}
function getClaimDetails(string _name, uint _number) view public returns(string, string){
require(_number >= 1);
require(keccak256(database[_name][_number]) != keccak256(""));
return(database[_name][_number],imageFiles[_name][_number]);
}
function refundStake(string _name, address _addressRefunded)  public {
require(victimDatabase[_addressRefunded][_name].stake > 0);
require(victimDatabase[_addressRefunded][_name].time <= block.timestamp + RefundTime);
_addressRefunded.transfer(victimDatabase[_addressRefunded][_name].stake);
}
}

The above code is the Apha version of Shitlist.