event-msg

Msg.sol (6354B)

---

 pragma solidity >=0.8.0;
 
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 contract EventMsg {
 	struct MultiHash {
 		uint8 l;
 		uint8 codecRLength;
 		uint8 prefixRLength;
 		bytes16 prefix;
 		bytes8 codec;
 	}
 
 	// Owner of contract
 	address public owner;
 
 	// All registered multicodecs
 	mapping (uint256 => MultiHash) public multiCodec;
 
 	// Implements Digest
 	uint256 public defaultDigestEncoding;
 
 	// Latest persisted message
 	bytes currentMsg;
 
 	// Editable base URI against which to look up token data by token id
 	bytes public baseURL;
 
 	// Implements Seal
 	uint256 public sealState;
 	uint8 constant CODECLIST_STATE = 1;
 	uint8 constant CODEC_STATE = 2;
 	// Implements Seal
 	uint256 constant public maxSealState = 3;
 	// Implements Seal
 	event SealStateChange(bool indexed _final, uint256 _sealState);
 
 	// Implements Msg
 	event Msg(bytes _multiHash);
 
 	constructor() {
 		owner = msg.sender;
 		addCodec(32, 0x12, "sha256");
 		setMsgCodec(0x12);
 		currentMsg = new bytes(32);
 		baseURL = "http://localhost/";
 	}
 
 	// Set the latest pesistent message on contract
 	function setMsg(bytes memory _digest) public {
 		MultiHash storage _hsh;
 
 		_hsh = multiCodec[defaultDigestEncoding];
 		require(_digest.length == _hsh.l);
 
 		currentMsg = _digest;
 		emit Msg(getMsg());
 	}
 
 	// Implements Msg
 	function getMsg() public view returns(bytes memory) {
 		return encodeDigest(currentMsg);
 	}
 
 	// Add a multicodec that can later be set as current codec
 	function addCodec(uint8 _length, uint64 _codecId, string memory _uriPrefix) public {
 		require(sealState & CODECLIST_STATE == 0, 'ERR_SEAL_CODECLIST');
 		bytes memory prefixBytes;
 
 		prefixBytes = bytes(_uriPrefix);
 		require(prefixBytes.length <= 16, 'ERR_PREFIX_TOO_LONG');
 		MultiHash memory _hsh;
 		uint8 c;
 
 		c = 7;
 		while (c >= 0) {
 			uint64 mask = uint64(0xff << (c * 8));
 			if ((mask & _codecId) > 0) {
 				break;
 			}
 			c--;
 		}
 		_hsh.codecRLength = c + 1;
 		_hsh.codec = bytes8(_codecId << ((7 - c) * 8));
 		_hsh.prefixRLength = uint8(prefixBytes.length);
 		_hsh.prefix = bytes16(prefixBytes);
 		_hsh.l = _length;
 		
 		multiCodec[uint256(_codecId)] = _hsh;
 	}
 
 	// Set the current multicodec to use for multihash generation
 	function setMsgCodec(uint256 _codec) public {
 		require(sealState & CODECLIST_STATE == 0, 'ERR_SEAL_CODEC');
 		MultiHash storage _hsh;
 
 		_hsh = multiCodec[_codec];
 		require(_hsh.l > 0);
 
 		defaultDigestEncoding = _codec;
 		currentMsg = new bytes(_hsh.l);
 
 		emit Msg(getMsg());
 	}
 
 	// Seal the given state
 	function seal(uint256 _state) public returns(uint256) {
 		require(_state < 16, 'ERR_INVALID_STATE');
 		require(_state & sealState == 0, 'ERR_ALREADY_LOCKED');
 		sealState |= _state;
 		emit SealStateChange(sealState == maxSealState, sealState);
 		return uint256(sealState);
 	}
 
 	// Generate a multihash from the given digest and current selected multicodec
 	function toMultiHash(bytes memory _digest, uint256 _codec) private view returns(bytes memory) {
 		MultiHash storage m;
 		bytes memory r;
 
 		m = multiCodec[_codec];
 		r = new bytes(_digest.length + m.l + m.codecRLength);
 
 		uint256 i = 0;
 		for (i; i < m.codecRLength; i++) {
 			r[i] = m.codec[i];
 		}
 		r[i] = bytes1(m.l);
 		i++;
 		for (uint256 j = 0; j < _digest.length; j++) {
 			r[i+j] = _digest[j];	
 		}
 
 		return r;
 	}
 
 	// Implements Digest
 	function encodeDigest(bytes memory _digest) public view returns(bytes memory) {
 		return toMultiHash(_digest, defaultDigestEncoding);
 	}
 
 	// Implements Digest
 	function encodeDigest(bytes memory _digest, uint256 _codec) public view returns(bytes memory) {
 		return toMultiHash(_digest, _codec);
 	}
 
 	// Implements Digest
 	function haveDigestEncoding(uint256 _codec) public view returns(bool) {
 		MultiHash memory m;
 
 		m = multiCodec[_codec];
 		return m.l > 0;
 	}
 
 	// Generate a URI representing the digest and the string prefix representation // of the currently selected multicodec
 	// Implements Locator
 	function toURI(bytes memory _digest) public view returns(string memory) {
 		MultiHash storage m;
 
 		bytes memory codecString;
 		bytes memory digestHex;
 	        uint256 l;
 	      
 	       	digestHex = toHex(_digest);	
 		m = multiCodec[defaultDigestEncoding];
 		l = m.prefixRLength;
 		codecString = new bytes(l + digestHex.length + 1);
 		for (uint256 i = 0; i < l; i++) {
 			codecString[i] = m.prefix[i];
 		}
 		codecString[l] = 0x3a;
 		l++;
 
 		for (uint256 i = 0; i < digestHex.length; i++) {
 			codecString[l+i] = digestHex[i];
 		}
 		return string(codecString);
 
 	}
 
 	// Allow mutable explicit url base
 	function setBaseURL(string memory _baseString) public {
 		bytes memory _base;
 		uint256 l;
 		require(msg.sender == owner);
 		
 		_base = bytes(_baseString);
 		l = _base.length;
 		if (_base[l-1] != 0x2f) {
 			l++;
 		}
 		baseURL = new bytes(l);
 		for (uint256 i = 0; i < _base.length; i++) {
 			baseURL[i] = _base[i];
 		}
 		if (l != _base.length) {
 			baseURL[_base.length] = "/";
 		}
 	}
 
 	// Implements Locator
 	function toURL(bytes memory _digest) public view returns(string memory) {
 		bytes memory out;
 		bytes memory _hexDigest;
 		uint256 c;
 
 		_hexDigest = toHex(_digest);
 	
 		c = baseURL.length;
 		out = new bytes(_hexDigest.length + c);
 
 		for (uint256 i = 0; i < c; i++) {
 			out[i] = baseURL[i];
 		}
 		for (uint256 i = 0; i < _hexDigest.length; i++) {
 			out[c] = _hexDigest[i];
 			c++;
 		}
 		return string(out);
 	}
 
 	// TODO: move to internal library method
 	// bytes to hex conversion
 	function toHex(bytes memory _data) public pure returns(bytes memory) {
 		bytes memory out;
 		uint8 t;
 		uint256 c;
 
 		out = new bytes(_data.length * 2);
 		c = 0;
 		for (uint256 i = 0; i < 32; i++) {
 			t = (uint8(_data[i]) & 0xf0) >> 4;
 			if (t < 10) {
 				out[c] = bytes1(t + 0x30);
 			} else {
 				out[c] = bytes1(t + 0x57);
 			}
 			t = uint8(_data[i]) & 0x0f;
 			if (t < 10) {
 				out[c+1] = bytes1(t + 0x30);
 			} else {
 				out[c+1] = bytes1(t + 0x57);
 			}
 			c += 2;
 		}
 		return out;
 	}
 
 	// Implements ERC165
 	function supportsInterface(bytes4 _interfaceID) public pure returns(bool) {
 		if (_interfaceID == 0x982ab05d) { // Digest
 			return true;
 		}
 		if (_interfaceID == 0x01ffc9a7) { // ERC165
 			return true;
 		}
 		if (_interfaceID == 0xa3002595) { // Msg
 			return true;
 		}
 		if (_interfaceID == 0xed75b333) { // Locator
 			return true;
 		}
 		if (_interfaceID == 0x0d7491f8) { // Seal
 			return true;
 		}
 		return false;
 	}
 }