eth-address-index/solidity/AddressDeclarator.sol

130 lines
3.6 KiB
Solidity
Raw Normal View History

2021-01-10 22:03:26 +01:00
pragma solidity >0.6.11;
2020-12-29 16:08:49 +01:00
// SPDX-License-Identifier: GPL-3.0-or-later
contract AddressDeclarator {
2020-12-29 19:44:14 +01:00
mapping( address => address[] ) declarationIndex;
mapping( bytes32 => uint256 ) declarationContentIndex; // the _latest_ content pointer for the declarator to subject mapping
2020-12-29 19:44:14 +01:00
mapping( address => address[] ) declarator;
mapping( address => address[] ) declaratorReverse;
mapping( bytes32 => bool ) declarationExistIndex;
2020-12-29 17:33:00 +01:00
bytes32[][] public contents;
2021-04-30 17:13:58 +02:00
event DeclarationAdded(address _declarator, address _subject, bytes32 _proof);
2021-01-10 22:03:26 +01:00
constructor(bytes32 _initialDescription) public {
2020-12-29 17:33:00 +01:00
bytes32[] memory foundation;
contents.push(foundation);
contents[contents.length-1].push(blockhash(block.number));
addDeclaration(msg.sender, _initialDescription);
}
function toReference(address _declarator, address _subject) private pure returns ( bytes32 ) {
bytes32 k;
bytes memory signMaterial = new bytes(40);
bytes memory addrBytes = abi.encodePacked(_declarator);
for (uint256 i = 0; i < 20; i++) {
signMaterial[i] = addrBytes[i];
}
addrBytes = abi.encodePacked(_subject);
for (uint256 i = 0; i < 20; i++) {
signMaterial[i+20] = addrBytes[i];
}
k = sha256(signMaterial);
return k;
}
function toReference(address _declarator, address _subject, bytes32 _proof) private pure returns ( bytes32[2] memory ) {
bytes32 k;
bytes32[2] memory ks;
bytes memory signMaterial = new bytes(64);
k = toReference(_declarator, _subject);
for (uint256 i = 0; i < 32; i++) {
signMaterial[i] = k[i];
}
for (uint256 i = 0; i < 32; i++) {
signMaterial[i+32] = _proof[i];
}
ks[0] = k;
ks[1] = sha256(signMaterial);
return ks;
}
2021-04-30 17:13:58 +02:00
// Implements Declarator
2020-12-29 17:33:00 +01:00
function declaratorCount(address _subject) public view returns ( uint256 ) {
return declarator[_subject].length;
}
2021-04-30 17:13:58 +02:00
// Implements Declarator
2020-12-29 19:44:14 +01:00
function declaratorAddressAt(address _subject, uint256 _idx) public view returns ( address ) {
return declarator[_subject][_idx];
}
2021-04-30 17:13:58 +02:00
// Implements Declarator
2020-12-29 17:33:00 +01:00
function addDeclaration(address _subject, bytes32 _proof) public returns ( bool ) {
bytes32[2] memory ks;
2020-12-29 17:33:00 +01:00
bytes32[] memory declarationContents;
2020-12-29 19:44:14 +01:00
uint256 idx;
ks = toReference(tx.origin, _subject, _proof);
idx = declarationContentIndex[ks[0]];
2020-12-29 19:44:14 +01:00
if (idx == 0) { // This also works for the constructor :)
declarator[_subject].push(tx.origin);
contents.push(declarationContents);
declarationIndex[tx.origin].push(_subject);
2020-12-29 17:33:00 +01:00
}
2020-12-29 19:44:14 +01:00
idx = contents.length-1;
declarationContentIndex[ks[0]] = idx;
2020-12-29 19:44:14 +01:00
contents[idx].push(_proof);
2020-12-29 17:33:00 +01:00
declarationExistIndex[ks[1]] = true;
2020-12-29 17:33:00 +01:00
return true;
}
2021-04-30 17:13:58 +02:00
// Implements Declarator
2020-12-29 17:33:00 +01:00
function declaration(address _declarator, address _subject) public view returns ( bytes32[] memory ) {
bytes32 k;
2020-12-29 19:44:14 +01:00
uint256 idx;
2020-12-29 17:33:00 +01:00
k = toReference(_declarator, _subject);
2020-12-29 19:44:14 +01:00
idx = declarationContentIndex[k];
return contents[idx];
}
// Implements Declarator
function haveDeclaration(address _declarator, address _subject, bytes32 _proof) public view returns (bool) {
bytes32[2] memory ks;
ks = toReference(_declarator, _subject, _proof);
return declarationExistIndex[ks[1]];
}
2021-04-30 17:13:58 +02:00
// Implements Declarator
2020-12-29 19:44:14 +01:00
function declarationCount(address _declarator) public view returns ( uint256 ) {
return declarationIndex[_declarator].length;
}
2021-04-30 17:13:58 +02:00
// Implements Declarator
2020-12-29 19:44:14 +01:00
function declarationAddressAt(address _declarator, uint256 _idx) public view returns ( address ) {
return declarationIndex[_declarator][_idx];
2020-12-29 17:33:00 +01:00
}
2021-04-30 17:22:32 +02:00
// Implements EIP165
function supportsInterface(bytes4 _sum) public pure returns (bool) {
if (_sum == 0x27beb910) { // Implements Declarator
return true;
}
if (_sum == 0x01ffc9a7) { // EIP165
return true;
}
return false;
2021-04-30 17:22:32 +02:00
}
2020-12-29 16:08:49 +01:00
}