forked from github-linguist/linguist
-
Notifications
You must be signed in to change notification settings - Fork 0
/
aeproof.aes
142 lines (117 loc) · 4.23 KB
/
aeproof.aes
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
/*
contract AeToken {
function balanceOf(address addr) returns (uint256)
}
contract AEProof {
AeToken aeToken
mapping (bytes32 => Proof) private proofs
mapping (address => bytes32[]) private proofsByOwner
function AEProof(address tokenAddress) {
aeToken = AeToken(tokenAddress)
}
struct Proof {
address owner
uint timestamp
uint proofBlock
string comment
string ipfsHash
string document
}
function notarize(string document, string comment, string ipfsHash) onlyTokenHolder {
var proofHash = calculateHash(document)
var proof = proofs[proofHash]
require(proof.owner == address(0))
proof.owner = msg.sender
proof.timestamp = block.timestamp
proof.proofBlock = block.number
proof.comment = comment
proof.ipfsHash = ipfsHash
proof.document = document
proofsByOwner[msg.sender].push(proofHash)
}
function calculateHash(string document) constant returns (bytes32) {
return sha256(document)
}
function getProof(string document) constant returns (address owner, uint timestamp, uint proofBlock, string comment, string ipfsHash, string storedDocument) {
var calcHash = calculateHash(document)
var proof = proofs[calcHash]
require(proof.owner != address(0))
owner = proof.owner
timestamp = proof.timestamp
proofBlock = proof.proofBlock
comment = proof.comment
ipfsHash = proof.ipfsHash
storedDocument = proof.document
}
function getProofByHash(bytes32 hash) constant returns (address owner, uint timestamp, uint proofBlock, string comment, string ipfsHash, string storedDocument) {
var proof = proofs[hash]
require(proof.owner != address(0))
owner = proof.owner
timestamp = proof.timestamp
proofBlock = proof.proofBlock
comment = proof.comment
ipfsHash = proof.ipfsHash
storedDocument = proof.document
}
function hasProof(string document) constant returns (bool) {
var calcHash = calculateHash(document)
var storedProof = proofs[calcHash]
if (storedProof.owner == address(0)) {
return false
}
return true
}
function getProofsByOwner(address owner) constant returns (bytes32[]) {
return proofsByOwner[owner]
}
modifier onlyTokenHolder() {
uint balance = aeToken.balanceOf(msg.sender)
require(balance > 0)
_
}
}
*/
// No imports yet
// import contract aetoken
// fun balanceOf(addr : Address) : uint
contract AEProof =
record proof = { owner: address
, timestamp: uint
, proofBlock: uint
, comment: string
, ipfsHash: string
, document: string
}
record state = { aeToken : aetoken,
proofs : map(uint, proof),
proofsByOwner : map(address, array(uint)) }
function notarize(document:string, comment:string, ipfsHash:hash) =
let _ = require(aetoken.balanceOf(caller()) > 0, "false")
let proofHash: uint = calculateHash(document)
let proof : proof = Map.get_(proofHash, state().proofs)
let _ = require(proof.owner == #0, "false")
let proof' : proof = proof { owner = caller()
, timestamp = block().timestamp
, proofBlock = block().height
, comment = comment
, ipfsHash = ipfsHash
, document = document
}
state{ proofsByOwner = Map.insert(caller, proofHash, state.proofsByOwner),
proofs = Map.insert(proofHash, proof', state.proofs) }
function calculateHash(document: string) : uint = sha256(document)
function getProof(document) : proof =
let calcHash = calculateHash(document)
let proof = Map.get_(calcHash, state().proofs)
let _ = require(proof.owner != #0, "false")
proof
function getProofByHash(hash: uint) : proof =
let proof = Map.get_(hash, state().proofs)
let _ = require(proof.owner != #0, "false")
proof
function hasProof(document: string) : bool =
let calcHash = calculateHash(document)
let storedProof = Map.get_(calcHash, state().proofs)
storedProof.owner != #0
function getProofsByOwner(owner: address): array(uint) =
Map.get(owner, state())