├── 1. zites.md
├── 10. editing user data.md
├── 11. merger sites.md
├── 12. merged content.md
├── 13. ugly things.md
├── 2. security.md
├── 3. cloning zites.md
├── 4. creating static zite.md
├── 5. zeroframe.md
├── 6. databases.md
├── 7. changing tables.md
├── 8. dbschema.md
├── 9. user content.md
├── README.md
├── SUMMARY.md
├── downloads
    ├── ZeroAuth.js
    ├── ZeroFS.js
    ├── ZeroPage.js
    ├── blog.html
    ├── blog_library.zip
    ├── blog_modern.zip
    ├── blog_single.zip
    ├── notepad.html
    ├── notepad_single.zip
    ├── notepad_zerofs.zip
    ├── notepad_zeropage.zip
    ├── portfolio.zip
    ├── voting.html
    ├── voting_library.zip
    ├── voting_modern.zip
    └── voting_single.zip
└── extra
    ├── 1. zeropage.md
    └── 2. zeronet vs. others.md


/1. zites.md:
--------------------------------------------------------------------------------
  1 | # ZeroNet sites
  2 | 
  3 | ZeroNet sites, or *zites*, as we call them, are distributed across the network.
  4 | 
  5 | 
  6 | ## Why ZeroNet is better than Internet
  7 | 
  8 | ### Internet
  9 | 
 10 | Here is the scheme of the Internet:
 11 | 
 12 |      ________       +--------+   |                |
 13 |     |        |      | iPhone |   |                |
 14 |     |  iPad  |      +--------+   |                |      ______________
 15 |     |________|-----------+       |                |     |              |
 16 |                          |       |    ________    |  +--|    Google    |
 17 |        _________         |       |   |  /..\  |   |  |  |______________|
 18 |       | Windows |--------+-------|---|  \__/  |---|--+   ______________
 19 |       |_________|                |   |___||___|   |  |  |              |
 20 |       |_|_|_|_|_|                |                |  +--|   Facebook   |
 21 |       |_|_|_|_|_|                |                |     |______________|
 22 |                                  |                |
 23 |            *Devices*             |   *Provider*   |         *Sites*
 24 | 
 25 | And that's what happens if your provider is down or the server you're trying to connect is down or blocked:
 26 | 
 27 |      ________       +--------+   |                |
 28 |     |        |      | iPhone |   |                |
 29 |     |  iPad  |      +--------+   |                |      ______________
 30 |     |________|-----------+       |                |     |              |
 31 |                          |       |    ________    |     |    Google    |
 32 |        _________         |       |   |\/\/\/\/|   |     |______________|
 33 |       | Windows |--------+-------|---|/\ No /\|   |      ______________
 34 |       |_________|                |   |\/\/\/\/|   |     |              |
 35 |       |_|_|_|_|_|                |                |     |   Facebook   |
 36 |       |_|_|_|_|_|                |                |     |______________|
 37 |                                  |                |
 38 |            *Devices*             |   *Provider*   |         *Sites*
 39 | 
 40 | You've got no access to the server.
 41 | 
 42 | 
 43 | ### ZeroNet
 44 | 
 45 | And this is ZeroNet:
 46 | 
 47 |      ________       +--------+
 48 |     |        |      | iPhone |
 49 |     |  iPad  |      +--------+
 50 |     |________|-----------+    
 51 |          |               |    
 52 |        __|______         |    
 53 |       | Windows |--------+    
 54 |       |_________|             
 55 |       |_|_|_|_|_|             
 56 |       |_|_|_|_|_|             
 57 |                               
 58 |       *Devices = zites*          
 59 | 
 60 | If *iPhone* is down or blocked:
 61 | 
 62 |      ________       +--------+
 63 |     |        |      |\/ No \/|
 64 |     |  iPad  |      +--------+
 65 |     |________|                
 66 |          |                    
 67 |        __|______              
 68 |       | Windows |             
 69 |       |_________|             
 70 |       |_|_|_|_|_|             
 71 |       |_|_|_|_|_|             
 72 |                               
 73 |       *Devices = zites*          
 74 | 
 75 | Other peers still have access to the zites.
 76 | 
 77 | 
 78 | ## Installing ZeroNet
 79 | 
 80 | To use ZeroNet on Windows, Mac or Linux machine, install it first. Visit `https://zeronet.io` and download ZeroNet there.
 81 | 
 82 | 
 83 | ## Visiting zites
 84 | 
 85 | ZeroNet installs a local server on your computer, on *http://127.0.0.1:43110* address. When you run ZeroNet, a browser window opens.
 86 | 
 87 | On the left, you can see the list of zites hosted by your machine, and a few links to other helpful zites. Click zite to open (or download) it. Feel free to visit some of them now.
 88 | 
 89 | I said *download* because that's how ZeroNet works. Let's discuss it later.
 90 | 
 91 | 
 92 | ## Getting ZeroID
 93 | 
 94 | A user can register on such *Internet* sites as Google, eBay, etc. On zites, registration is not technically possible, but don't worry. Instead, ZeroNet introduces *Certificate Authorities*. For example, [ZeroID](http://127.0.0.1:43110/1iD5ZQJMNXu43w1qLB8sfdHVKppVMduGz/). This is the most popular certificate provider, so let's register there first.
 95 | 
 96 | Visit [ZeroID](http://127.0.0.1:43110/1iD5ZQJMNXu43w1qLB8sfdHVKppVMduGz/) and register with any nickname you like. (*Note: If you don't want to reveal your IP, set up ZeroNet to use TOR.*)
 97 | 
 98 | You enterd nickname, but what about password? It was generated automatically. There is a `users.json` file in ZeroNet root directory. When you register on *ZeroID*, new entries appear in `users.json`: your public and private keys for *ZeroID*. You shouldn't share your private key - it's your password. And public key is your login - you share it with zites you post on. Your nickname is also stored there. If you lose `users.json` or manually change your public and private keys or nickname, you cannot access your account. It's a good idea to backup this file.
 99 | 
100 | 
101 | ## Getting ZeroTalk account
102 | 
103 | Now, let's check a zite which let you use your *ZeroID*. *ZeroTalk* is a perfect choice. It's a popular forum.
104 | 
105 | Let's visit [ZeroTalk](http://127.0.0.1:43110/1TaLkFrMwvbNsooF4ioKAY9EuxTBTjipT/). Go to *Test messages* topic, press *Sign in as...* and choose *{yourusername}@zeroid.bit*. Enter some kind of `Hello, world!` and press *Submit comment*. Instead of `Hello, world!`, you can publish this tutorial. :) 
106 | 
107 | Notice `Forums: English · Dansk · Español · Français ...` on the top of the page and select your language. If you are from *China*, better go to the special [New GFW Talk](http://127.0.0.1:43110/19BPUZYAdCMxExKHoVSG3cG95wfUfFTEC9/) zite.
108 | 


--------------------------------------------------------------------------------
/10. editing user data.md:
--------------------------------------------------------------------------------
  1 | # Editing user data
  2 | 
  3 | Now let's try to edit user content. Remember, we are going to write a voting system.
  4 | 
  5 | 
  6 | ## `data.json` files
  7 | 
  8 | Now let's write a function which will add a question.
  9 | 
 10 | 
 11 | First of all, we will take our `js/files.js` program and include it to `index.html`:
 12 | 
 13 |     function readFile(file, callback) {
 14 |         zeroFrame.cmd("fileGet", [file, false], callback);
 15 |     }
 16 |     
 17 |     function writeFile(file, content, callback) {
 18 |         zeroFrame.cmd("fileWrite", [file, base64Encode(content)], callback);
 19 |     }
 20 |     
 21 |     function base64Encode(content) {
 22 |         content = encodeURIComponent(content); // Split to bytes in % notation
 23 |         content = unescape(content); // Join % notation as bytes (not as chars)
 24 |         return btoa(content);
 25 |     }
 26 | 
 27 | 
 28 | Now, let's write `addQuestion()` function in `js/votes.js`:
 29 | 
 30 |     function addQuestion(question, answers, callback) {
 31 |         ...
 32 |     }
 33 | 
 34 | 
 35 | If somebody wants to add a question, he has to be authorizated with ZeroID:
 36 | 
 37 |     function addQuestion(question, answers, callback) {
 38 |         authAsZeroID(function(user) {
 39 |             // User rejected to authorizate
 40 |             if(!user) {
 41 |                 callback(false);
 42 |                 return;
 43 |             }
 44 |             
 45 |             ...
 46 |         });
 47 |     }
 48 | 
 49 | 
 50 | Let's open JSON file of user:
 51 | 
 52 |     function addQuestion(question, answers, callback) {
 53 |         authAsZeroID(function(user) {
 54 |             // User rejected to authorizate
 55 |             if(!user) {
 56 |                 callback(false);
 57 |                 return;
 58 |             }
 59 |             
 60 |             readFile("data/users/" + user.address + "/data.json", function(content) {
 61 |                 content = content || "";
 62 |                 
 63 |                 // Parse JSON
 64 |                 try {
 65 |                     content = JSON.parse(content);
 66 |                 } catch(e) {
 67 |                     content = {
 68 |                         questions: [],
 69 |                         answers: {},
 70 |                         next_question_id: 0
 71 |                     };
 72 |                 }
 73 |                 
 74 |                 ...
 75 |             });
 76 |         });
 77 |     }
 78 | 
 79 | Notice that we try to open file with user address. User address is its public key for ZeroID. If user uses KaffieID, public key and username (`user` property) will be different.
 80 | 
 81 | 
 82 | Now we add question, save JSON and publish user's `content.json`:
 83 | 
 84 |     function addQuestion(question, answers, callback) {
 85 |         authAsZeroID(function(user) {
 86 |             // User rejected to authorizate
 87 |             if(!user) {
 88 |                 callback(false);
 89 |                 return;
 90 |             }
 91 |             
 92 |             readFile("data/users/" + user.address + "/data.json", function(content) {
 93 |                 content = content || "";
 94 |                 
 95 |                 // Parse JSON
 96 |                 try {
 97 |                     content = JSON.parse(content);
 98 |                 } catch(e) {
 99 |                     content = {
100 |                         questions: [],
101 |                         answers: {},
102 |                         next_question_id: 0
103 |                     };
104 |                 }
105 |                 
106 |                 var id = content.next_question_id;
107 |                 content.questions.push({
108 |                     id: id++,
109 |                     question: question,
110 |                     answers: answers.join("\n"),
111 |                     date_added: Math.floor(Date.now() / 1000)
112 |                 });
113 |                 
114 |                 content = JSON.stringify(content);
115 |                 
116 |                 writeFile("data/users/" + user.address + "/data.json", content, function() {
117 |                     zeroFrame.cmd("sitePublish", {
118 |                         inner_path: "data/users/" + user.address + "/content.json"
119 |                     }, function() {
120 |                         callback(id);
121 |                     });
122 |                 });
123 |             });
124 |         });
125 |     }
126 | 
127 | Notice that we don't pass `privatekey` to `sitePublish` command. That's because `privatekey: null` means "sign using user's private key".
128 | 
129 | We also sign `data/users/{address}/content.json`, but it is possible that it does not exist (eg. user added question first time). Hopefully, ZeroNet creates a `content.json` for us if it does not exist.
130 | 
131 | 
132 | Let's check our code. Open DevTools, reload page and type the following in the console:
133 | 
134 |     addQuestion("What's nofish's name?", ["nofish", "Tomas", "Jack"], console.log.bind(console));
135 | 
136 | Authorizate using ZeroID (if you are asked) and watch `data/votes.db`.
137 | 
138 | 
139 | ## Answers
140 | 
141 | Try to write `addAnswer()` function for yourself first.
142 | 
143 | Answer:
144 | 
145 |     function addQuestion(questionId, answerId, callback) {
146 |         authAsZeroID(function(user) {
147 |             // User rejected to authorizate
148 |             if(!user) {
149 |                 callback(false);
150 |                 return;
151 |             }
152 |             
153 |             readFile("data/users/" + user.address + "/data.json", function(content) {
154 |                 content = content || "";
155 |                 
156 |                 // Parse JSON
157 |                 try {
158 |                     content = JSON.parse(content);
159 |                 } catch(e) {
160 |                     content = {
161 |                         questions: [],
162 |                         answers: {},
163 |                         next_question_id: 0
164 |                     };
165 |                 }
166 |                 
167 |                 content.answers[questionId] = answerId;
168 |                 
169 |                 content = JSON.stringify(content);
170 |                 
171 |                 writeFile("data/users/" + user.address + "/data.json", content, function() {
172 |                     zeroFrame.cmd("sitePublish", {
173 |                         inner_path: "data/users/" + user.address + "/content.json"
174 |                     }, callback);
175 |                 });
176 |             });
177 |         });
178 |     }
179 | 
180 | 
181 | Note that we have similar functions. Let's write a library function instead:
182 | 
183 |     function editUserData(handler, callback) {
184 |         authAsZeroID(function(user) {
185 |             // User rejected to authorizate
186 |             if(!user) {
187 |                 callback(false);
188 |                 return;
189 |             }
190 |             
191 |             readFile("data/users/" + user.address + "/data.json", function(content) {
192 |                 content = content || "";
193 |                 
194 |                 // Parse JSON
195 |                 try {
196 |                     content = JSON.parse(content);
197 |                 } catch(e) {
198 |                     content = {
199 |                         questions: [],
200 |                         answers: {},
201 |                         next_question_id: 0
202 |                     };
203 |                 }
204 |                 
205 |                 handler(content);
206 |                 
207 |                 content = JSON.stringify(content);
208 |                 
209 |                 writeFile("data/users/" + user.address + "/data.json", content, function() {
210 |                     zeroFrame.cmd("sitePublish", {
211 |                         inner_path: "data/users/" + user.address + "/content.json"
212 |                     }, callback);
213 |                 });
214 |             });
215 |         });
216 |     }
217 |     
218 |     function addQuestion(question, answers, callback) {
219 |         var id;
220 |         editUserData(function(content) {
221 |             id = content.next_question_id;
222 |             
223 |             content.questions.push({
224 |                 id: content.next_question_id++,
225 |                 question: question,
226 |                 answers: answers.join("\n"),
227 |                 date_added: Math.floor(Date.now() / 1000)
228 |             });
229 |         }, function() {
230 |             callback(id);
231 |         });
232 |     }
233 |     
234 |     
235 |     function addAnswer(questionId, answerId, callback) {
236 |         editUserData(function(content) {
237 |             content.answers[questionId] = answerId;
238 |         }, callback);
239 |     }
240 | 
241 | 
242 | ## Reading data
243 | 
244 | Now we will write `getQuestionList()`, `getQuestion()` and `getAnswers()` functions:
245 | 
246 |     function getQuestionList(sort, callback) {
247 |         if(sort == "popular") {
248 |             zeroFrame.cmd("dbQuery", ["SELECT questions.*, CASE WHEN answers.answer_count IS NULL THEN 0 ELSE answers.answer_count END AS answer_count FROM questions LEFT JOIN (SELECT question_id, COUNT(*) as answer_count FROM answers GROUP BY question_id) AS answers ON (answers.question_id = questions.id) ORDER BY answers.answer_count DESC, questions.date_added DESC LIMIT 0, 10"], callback);
249 |         } else if(sort == "latest") {
250 |             zeroFrame.cmd("dbQuery", ["SELECT * FROM questions ORDER BY date_added DESC LIMIT 0, 10"], callback);
251 |         }
252 |     }
253 |     
254 |     function getQuestion(id, callback) {
255 |         zeroFrame.cmd("dbQuery", ["SELECT * FROM questions WHERE id = " + id], function(questions) {
256 |             zeroFrame.cmd("siteInfo", [], function(siteInfo) {
257 |                 if(siteInfo.cert_user_id) { // User logged in
258 |                     zeroFrame.cmd("dbQuery", ["SELECT answers.*, json.* FROM answers, json WHERE json.directory = \"users/" + siteInfo.auth_address + "\" AND answers.json_id = json.json_id AND answers.question_id = " + id], function(answer) {
259 |                         if(answer.length) {
260 |                             questions[0].answered = answer[0].answer_id;
261 |                             
262 |                             getAnswers(id, function(answers) {
263 |                                 questions[0].answers = answers;
264 |                                 callback(questions[0]);
265 |                             });
266 |                         } else {
267 |                             questions[0].answered = -1;
268 |                             callback(questions[0]);
269 |                         }
270 |                     });
271 |                 } else {
272 |                     questions[0].answered = -1;
273 |                     callback(questions[0]);
274 |                 }
275 |             });
276 |         });
277 |     }
278 |     
279 |     function getAnswers(id, callback) {
280 |         zeroFrame.cmd("dbQuery", ["SELECT answer_id, COUNT(*) as answer_count FROM answers WHERE question_id = " + id + " GROUP BY answer_id"], function(answers) {
281 |             var result = {};
282 |             for(var i = 0; i < answers.length; i++) {
283 |                 result[answers[i].answer_id] = answers[i].answer_count;
284 |             }
285 |             callback(result);
286 |         });
287 |     }
288 | 
289 | Now, core is finished. Only layout is left. As usual, [here](downloads/voting.html) is an example.
290 | 


--------------------------------------------------------------------------------
/11. merger sites.md:
--------------------------------------------------------------------------------
  1 | # Merger sites
  2 | 
  3 | Let's have a look at ZeroMe. It's a social network with about 10 000 users. And each user can write a lot of data. So, we would have to let ZeroMe use around 600 MB of storage. Really bad. Hopefully, ZeroNet introduces merger sites to solve this problem.
  4 | 
  5 | 
  6 | ## Structure
  7 | 
  8 | Imagine the following structure:
  9 | 
 10 |     ZeroMe = 500 MB
 11 |     |
 12 |     +-- data = 500 MB
 13 |     |   |
 14 |     |   +-- users = 500 MB
 15 |     |       |
 16 |     |       +-- user1 = 50 KB
 17 |     |       +-- user2 = 50 KB
 18 |     |       +-- user3 = 50 KB
 19 |     |       +-- user4 = 50 KB
 20 |     |       +-- user5 = 50 KB
 21 |     |       +-- user...
 22 |     |       +-- user10000 = 50 KB
 23 |     +-- index.js = 250 KB
 24 |     +-- index.css = 100 KB
 25 |     +-- index.html = 50 KB
 26 | 
 27 | Here, users have to download all other users' data (`userN` directories).
 28 | 
 29 | 
 30 | And the imagine this:
 31 | 
 32 |     ZeroMe = 400 KB
 33 |     |
 34 |     +-- index.js = 250 KB
 35 |     +-- index.css = 100 KB
 36 |     +-- index.html = 50 KB
 37 |     
 38 |     UserDB = 10 MB
 39 |     |
 40 |     +-- data = 10 MB
 41 |     |   |
 42 |     |   +-- userinfo = 10 MB
 43 |     |       |
 44 |     |       +-- user1 = 1 KB
 45 |     |       +-- user2 = 1 KB
 46 |     |       +-- user3 = 1 KB
 47 |     |       +-- user4 = 1 KB
 48 |     |       +-- user5 = 1 KB
 49 |     |       +-- user...
 50 |     |       +-- user10000 = 1 KB
 51 |     +-- index.html = 5 KB
 52 |     
 53 |     Hub1 = 167 MB
 54 |     |
 55 |     +-- data = 167 MB
 56 |     |   |
 57 |     |   +-- users = 167 MB
 58 |     |       |
 59 |     |       +-- user1 = 50KB
 60 |     |       +-- user2 = 50KB
 61 |     |       +-- user...
 62 |     |       +-- user3333 = 50KB
 63 |     +-- index.html = 5 KB
 64 |     
 65 |     Hub2 = 167 MB
 66 |     |
 67 |     +-- data = 167 MB
 68 |     |   |
 69 |     |   +-- users = 167 MB
 70 |     |       |
 71 |     |       +-- user3334 = 50KB
 72 |     |       +-- user3335 = 50KB
 73 |     |       +-- user...
 74 |     |       +-- user6666 = 50KB
 75 |     +-- index.html = 5 KB
 76 |     
 77 |     Hub3 = 167 MB
 78 |     |
 79 |     +-- data = 167 MB
 80 |     |   |
 81 |     |   +-- users = 167 MB
 82 |     |       |
 83 |     |       +-- user6667 = 50KB
 84 |     |       +-- user6668 = 50KB
 85 |     |       +-- user...
 86 |     |       +-- user10000 = 50KB
 87 |     +-- index.html = 5 KB
 88 | 
 89 | So, we have splitted data to different zites. That's how merger sites work. *ZeroMe* (`1MeFqFfFFGQfa1J3gJyYYUvb5Lksczq7nH` in reality) has only layout and code, *UserDB* (`1UDbADib99KE9d3qZ87NqJF2QLTHmMkoV`) user metadata, while other zites - *hubs* have other data. Of course, downloading these hubs is optional.
 90 | 
 91 | For example, if you download `ZeroMe`, `UserDB` and `Hub1`, you can communicate with `user878` and `user678` and learn that there are also `user5412`, `user3453` and `user6789` and that they are assigned to `Hub2` and `Hub3` zites. If you want to say *Hello!* to `user6789` or read his posts, you have to download `Hub3`. But usually you want to read *something*, not *everything*, and you download only 1-2 hubs.
 92 | 
 93 | 
 94 | ## Making merger site
 95 | 
 96 | First of all, let's make a new, empty zite. Open sidebar and name it `PostHere`. Remove all content from `<body>` of `index.html`. We will have data in hubs, and code in main `PostHere` zite.
 97 | 
 98 | 
 99 | ## Making hub
100 | 
101 | Let's make a new zite for content. This site address is `1RedXn7jxM23y4WsR7ByWzhjFaCcBJwVQ` for me.
102 | 
103 | Change `index.html` to:
104 | 
105 |     <!DOCTYPE html>
106 |     <html>
107 |         <head>
108 |             <meta charset="utf-8">
109 |             <meta http-equiv="content-type" content="text/html; charset=utf-8" />
110 |             <base href="" target="_top" id="base">
111 |             <script>
112 |                 base.href = document.location.href.replace("/media", "").replace("index.html", "").replace(/[&?]wrapper=False/, "").replace(/[&?]wrapper_nonce=[A-Za-z0-9]+/, "")
113 |             </script>
114 |         </head>
115 |         <body>
116 |             Use PostHere to watch content of this site.
117 |         </body>
118 |     </html>
119 | 
120 | Change zite title if you want to `Red Hub` and sign `content.json`.
121 | 
122 | 
123 | ## Configurating merger sites
124 | 
125 | Merger site (`1CyNApZ4zp7k3SSXsrW54vEFMHHBpDy3nm`, in my case) and merged site (`1RedXn7jxM23y4WsR7ByWzhjFaCcBJwVQ`) must agree to make connection.
126 | 
127 | 
128 | So, let's add the following to root `content.json` our merged site (`1RedXn7jxM23y4WsR7ByWzhjFaCcBJwVQ`):
129 | 
130 |     "merged_type": "PostHere",
131 | 
132 | 
133 | Now create a directory `merged-PostHere` in the root of merger site. We want users to sign this folder, so add:
134 | 
135 |     "ignore": "merged-.*",
136 | 
137 | ...somewhere to `content.json` of main site. To virtually fill it with merger site content, we request `Merger:PostHere` permission:
138 | 
139 |     +-------------------------------------------------------------------------+
140 |     |                          wrapperPermissionAdd                           |
141 |     +-------------------------------------------------------------------------+
142 |     | Request new permission for site                                         |
143 |     +-------------------------+-----------------------------------------------+
144 |     | Parameter               | Description                                   |
145 |     +-------------------------+-----------------------------------------------+
146 |     | permission              | Name of permission                            |
147 |     +-------------------------+-----------------------------------------------+
148 |     | Return: "Granted" if allowed, not send when disallowed                  |
149 |     +-------------------------------------------------------------------------+
150 | 
151 | 
152 | So, add the following to `js/index.js` file and add it to `index.html` of PostHere:
153 | 
154 |     window.zeroFrame = new ZeroFrame();
155 |     
156 |     function requestPermission(permission, callback) {
157 |         zeroFrame.cmd("siteInfo", [], function(siteInfo) {
158 |             // Already have permission
159 |             if(siteInfo.settings.permissions.indexOf(permission) > -1) {
160 |                 callback();
161 |                 return;
162 |             }
163 |             
164 |             zeroFrame.cmd("wrapperPermissionAdd", [permission], callback);
165 |         });
166 |     }
167 |     
168 |     requestPermission("Merger:PostHere", function() {
169 |         // TODO
170 |     });
171 | 
172 | 
173 | ## Accessing merged sites
174 | 
175 | ZeroNet doesn't provide us a way to read and write other site's content, so MergerSite plugin makes all `merged-...` directories virtual. So to ZeroNet `merged-PostHere` structure is:
176 | 
177 |     merged-PostHere
178 |     |
179 |     +-- merger.db
180 |     +-- 1RedXn7jxM23y4WsR7ByWzhjFaCcBJwVQ
181 |         |
182 |         +-- js
183 |         |   |
184 |         |   +-- ZeroFrame.js
185 |         +-- data
186 |         |   |
187 |         |   +-- users
188 |         |       |
189 |         |       +-- user1
190 |         |       |   |
191 |         |       |   +-- data.json
192 |         |       |   +-- content.json
193 |         |       +-- content.json
194 |         +-- index.html
195 | 
196 | We have set `db_path` to `merged-PostHere/merger.db` because ZeroNet can gather data only from files which are in database directory, which is in this case `merged-PostHere`.
197 | 
198 | So, if we want to access `data/users/{address}/data.json` of `1RedXn7jxM23y4WsR7ByWzhjFaCcBJwVQ`, we have to access `merged-PostHere/1RedXn7jxM23y4WsR7ByWzhjFaCcBJwVQ/data/users/{address}/data.json`.
199 | 
200 | In the following part of the tutorial, we will fill our `PostHere` zite with user content.
201 | 


--------------------------------------------------------------------------------
/12. merged content.md:
--------------------------------------------------------------------------------
  1 | ## Editing merged sites
  2 | 
  3 | In the previous part, we made a merger site and a merged site (hub) for our new zite, *PostHere*.
  4 | 
  5 | 
  6 | ## Creating directory for user content
  7 | 
  8 | First of all we have to create `data/users/content.json` in our hub. Nothing new here.
  9 | 
 10 |     {
 11 |         "ignore": ".*",
 12 |         "user_contents": {
 13 |             "cert_signers": {
 14 |                 "zeroid.bit": ["1iD5ZQJMNXu43w1qLB8sfdHVKppVMduGz"]
 15 |             },
 16 |             "permission_rules": {
 17 |                 ".*": {
 18 |                     "files_allowed": "data.json",
 19 |                     "max_size": 50000
 20 |                 }
 21 |             },
 22 |             "permissions": {}
 23 |         }
 24 |     }
 25 | 
 26 | - `ignore` - don't add users to `files` property.
 27 | - `user_contents` - user-signed content.
 28 | - `user_contents.cert_signers` - allowed *Certificate Authorities*.
 29 | - `user_contents.permission_rules` - multiuser permissions.
 30 | - `user_contents.permissions` - single user permissions.
 31 | 
 32 | ...And include it to root `content.json`:
 33 | 
 34 |     ...
 35 |     "ignore": "data/users/.*",
 36 |     "includes": {
 37 |         "data/users/content.json": {
 38 |             "signers": [],
 39 |             "signers_required": 1
 40 |         }
 41 |     },
 42 |     ...
 43 |     
 44 | 
 45 | Sign `content.json` and then `data/users/content.json`.
 46 | 
 47 | 
 48 | ## Database schema
 49 | 
 50 | As usual, we will use SQLite. Add this `dbschema.json` to main site:
 51 | 
 52 |     {
 53 |         "db_name": "merger",
 54 |         "db_file": "merged-PostHere/merger.db",
 55 |         "version": 3,
 56 |         "maps": {
 57 |             ".+/data/users/.+/content.json": {
 58 |                 "to_json_table": ["cert_user_id"]
 59 |             },
 60 |             ".+/data/users/.+/data.json": {
 61 |                 "to_table": [
 62 |                     {
 63 |                         "node": "posts",
 64 |                         "table": "posts"
 65 |                     }
 66 |                 ]
 67 |             }
 68 |         },
 69 |         "tables": {
 70 |             "json": {
 71 |                 "cols": [
 72 |                     ["json_id", "INTEGER PRIMARY KEY AUTOINCREMENT"],
 73 |                     ["site", "TEXT"],
 74 |                     ["directory", "TEXT"],
 75 |                     ["file_name", "TEXT"],
 76 |                     ["cert_user_id", "TEXT"]
 77 |                 ],
 78 |                 "indexes": ["CREATE UNIQUE INDEX path ON json(directory, site, file_name)"],
 79 |                 "schema_changed": 2
 80 |             },
 81 |             "posts": {
 82 |                 "cols": [
 83 |                     ["id", "integer"],
 84 |                     ["title", "text"],
 85 |                     ["content", "text"],
 86 |                     ["date_added", "integer"],
 87 |                     ["json_id", "integer references json(json_id)"]
 88 |                 ],
 89 |                 "indexes": [
 90 |                     "CREATE UNIQUE INDEX post_id ON posts(id)"
 91 |                 ],
 92 |                 "schema_changed": 2
 93 |             }
 94 |         }
 95 |     }
 96 | 
 97 | - Have a look at `version: 3`. This means: `json` table will now have `site` column, too. For merger sites, `site` is hub address. We also use `merged-PostHere` directory for database. This will be described later.
 98 | - Look at `.+/data/users/.+/content.json` object. It has `to_json_table` array with `["cert_user_id"]`. `json` table also has `cert_user_id` column. `to_json_table` means: "take `cert_user_id` property from file and use it for `cert_user_id` column of `json` table for this json". `cert_user_id` is username.
 99 | 
100 | 
101 | ### Getting username
102 | 
103 | So, sample content is:
104 | 
105 |     +-------------------------------------------------------------------------+
106 |     |                                  json                                   |
107 |     +---------+---------+-------------------+--------------+------------------+
108 |     | json_id | site    | directory         | file_name    | cert_user_id     |
109 |     +---------+---------+-------------------+--------------+------------------+
110 |     | 1       | 1Red... | data/users/1Cv... | data.json    | NULL             |
111 |     +---------+---------+-------------------+--------------+------------------+
112 |     | 2       | 1Red... | data/users/1CV... | content.json | ivanq@zeroid.bit |
113 |     +---------+---------+-------------------+--------------+------------------+
114 |     +-------------------------------------------------------------------------+
115 |     |                                  posts                                  |
116 |     +---------+-------------+--------------------------+------------+---------+
117 |     | id      | title       | content                  | date_added | json_id |
118 |     +---------+-------------+--------------------------+------------+---------+
119 |     | 1       | Hello world | My first post in this... | 1234567890 | 1       |
120 |     +---------+-------------+--------------------------+------------+---------+
121 | 
122 | Everything is OK until you want to get post author. For each post, you have to take `json_id`, then get `directory` column of this `json_id` in `json` table, then find a row in `json` table which has `directory` = `directory` of old `json_id` and `file_name` = `content.json` and then get `cert_user_id`. So, simplest DB query is:
123 | 
124 |     SELECT posts.*, json2.cert_user_id as username FROM posts, json, json AS json2 WHERE json.directory = json2.directory AND json2.file_name = "content.json" AND posts.json_id = json.json_id
125 | 
126 | Hopefully, ZeroNet has another option for this.
127 | 
128 |     ...
129 |     ".+/data/users/.+/content.json": {
130 |         "to_json_table": ["cert_user_id"],
131 |         "file_name": "data.json"
132 |     },
133 |     ...
134 | 
135 | `file_name` works like `JOIN`. For each user's `content.json`, ZeroNet find a row with same `site` and `directory` properties and with `file_name` = `data.json` and adds `cert_user_id` to this row. So, now structure is:
136 | 
137 |     +-------------------------------------------------------------------------+
138 |     |                                  json                                   |
139 |     +---------+---------+-------------------+--------------+------------------+
140 |     | json_id | site    | directory         | file_name    | cert_user_id     |
141 |     +---------+---------+-------------------+--------------+------------------+
142 |     | 1       | 1Red... | data/users/1Cv... | data.json    | ivanq@zeroid.bit |
143 |     +---------+---------+-------------------+--------------+------------------+
144 |     +-------------------------------------------------------------------------+
145 |     |                                  posts                                  |
146 |     +---------+-------------+--------------------------+------------+---------+
147 |     | id      | title       | content                  | date_added | json_id |
148 |     +---------+-------------+--------------------------+------------+---------+
149 |     | 1       | Hello world | My first post in this... | 1234567890 | 1       |
150 |     +---------+-------------+--------------------------+------------+---------+
151 | 
152 | ...and we can simplify our query:
153 | 
154 |     SELECT posts.*, json.cert_user_id AS username FROM posts, json WHERE posts.json_id = json.json_id
155 | 
156 | 
157 | So, now you can use your memory or previous sections to write the rest of the code. As you remember, ZeroNet uses virtual directories, for merger sites, so there is nothing new here expect file we change: `merged-PostHere/{hub}/data/users/{address}/data.json`.
158 | 
159 | 
160 | ## Adding and removing hubs
161 | 
162 | We can show users a list of hubs they doesn't have with `mergerSiteList` command.
163 | 
164 |     +-------------------------------------------------------------------------+
165 |     |                             mergerSiteList                              |
166 |     +-------------------------------------------------------------------------+
167 |     | Return merged sites.                                                    |
168 |     +-------------------------+-----------------------------------------------+
169 |     | Parameter               | Description                                   |
170 |     +-------------------------+-----------------------------------------------+
171 |     | query_site_info         | If True, then gives back detailed site info   |
172 |     |                         | for merged sites                              |
173 |     +-------------------------+-----------------------------------------------+
174 |     | Return: List of merger sites as object                                  |
175 |     +-------------------------------------------------------------------------+
176 | 
177 | Try to execute `zeroFrame.cmd("mergerSiteList", [false], console.log.bind(console));` You'll see `Object { 1RedXn7jxM23y4WsR7ByWzhjFaCcBJwVQ: "PostHere" }` or something like that in the console.
178 | 
179 | These commands are also often used by merger sites:
180 | 
181 |     +-------------------------------------------------------------------------+
182 |     |                              mergerSiteAdd                              |
183 |     +-------------------------------------------------------------------------+
184 |     | Start downloading new merger site (requires confirmation if called      |
185 |     | twice in 10 seconds)                                                    |
186 |     +-------------------------+-----------------------------------------------+
187 |     | Parameter               | Description                                   |
188 |     +-------------------------+-----------------------------------------------+
189 |     | addresses               | Site address or list of site addresses        |
190 |     +-------------------------+-----------------------------------------------+
191 |     | Return: Always "ok" (even before site is added)                         |
192 |     +-------------------------------------------------------------------------+
193 |     
194 |     +-------------------------------------------------------------------------+
195 |     |                            mergerSiteDelete                             |
196 |     +-------------------------------------------------------------------------+
197 |     | Stop seeding and delete a merged site                                   |
198 |     +-------------------------+-----------------------------------------------+
199 |     | Parameter               | Description                                   |
200 |     +-------------------------+-----------------------------------------------+
201 |     | address                 | Site address                                  |
202 |     +-------------------------+-----------------------------------------------+
203 |     | Return: "ok" or object with "error" property                            |
204 |     +-------------------------------------------------------------------------+
205 | 
206 | 
207 | ## Example
208 | 
209 | As usually, you can watch finished site [here](downloads/posthere.html) and hub [here](downloads/postherehub.html).
210 | 


--------------------------------------------------------------------------------
/13. ugly things.md:
--------------------------------------------------------------------------------
  1 | # Ugly things
  2 | 
  3 | This part is for developers who use ZeroNet and ZeroFrame API often. Here I'll talk about some strange things in ZeroFrame API which I know only because I read source code.
  4 | 
  5 | 
  6 | ## `dbQuery`
  7 | 
  8 | ### `?` placeholder
  9 | 
 10 | From ZeroMe source code:
 11 | 
 12 |     return Page.cmd("dbQuery", [
 13 |         "SELECT * FROM json WHERE ?", {
 14 |             directory: directory
 15 |         }
 16 |     ], function(subject_rows) {
 17 | 
 18 | That is equal to (See note 1):
 19 | 
 20 |     SELECT * FROM json WHERE
 21 |         directory = ${directory}
 22 | 
 23 | You can also use multiple key/value pairs, that means:
 24 | 
 25 |     SELECT * FROM json WHERE
 26 |         key1 = ${value1} AND
 27 |         key2 = ${value2} AND
 28 |         key3 = ${value3}
 29 | 
 30 | 
 31 | If you want to make some condition negative, prepend key with `not__`:
 32 | 
 33 |     Page.cmd("dbQuery", [
 34 |         "SELECT * FROM json WHERE ?", {
 35 |             not__json_id: 2,
 36 |             file_name: "data.json"
 37 |         }
 38 |     ], handler);
 39 | 
 40 |     SELECT * FROM json WHERE
 41 |         json_id != 2 AND
 42 |         file_name = "data.json"
 43 | 
 44 | 
 45 | You can also use array as value: (See note 2)
 46 | 
 47 |     Page.cmd("dbQuery", [
 48 |         "SELECT * FROM json WHERE ?", {
 49 |             not__json_id: [2, 3],
 50 |             file_name: ["content.json", "data.json"]
 51 |         }
 52 |     ], handler);
 53 | 
 54 |     SELECT * FROM json WHERE
 55 |         json_id NOT IN (2, 3) AND
 56 |         file_name IN ("content.json", "data.json")
 57 | 
 58 | 
 59 | ### `:` placeholder
 60 | 
 61 | But what if you want to use some special rules (like `A=a and (B=b or C=c)`) but still want to use placeholders? Use `:`!
 62 | 
 63 | From ZeroMe source code:
 64 | 
 65 |     return Page.cmd("dbQuery", ["SELECT * FROM json WHERE site = :site AND directory = :directory LIMIT 1", params], (function(_this) {
 66 | 
 67 | Pass parameters as usual (object as second argument) and then use `:{key}` placeholder to get that value!
 68 | 
 69 | 
 70 | ## User content
 71 | 
 72 | Remember this `data/users/content.json` we often use?
 73 | 
 74 |     {
 75 |         "files": {},
 76 |         "ignore": ".*",
 77 |         "user_contents": {
 78 |             "cert_signers": {
 79 |                 "zeroid.bit": ["1iD5ZQJMNXu43w1qLB8sfdHVKppVMduGz"]
 80 |             },
 81 |             "permission_rules": {
 82 |                 ".*": {
 83 |                     "files_allowed": "data.json",
 84 |                     "max_size": 50000
 85 |                 }
 86 |             },
 87 |             "permissions": {}
 88 |         }
 89 |     }
 90 | 
 91 | Currently only site admin can sign user content (eg. delete posts). And what if we want to add moderators?
 92 | 
 93 |     ...
 94 |     "permission_rules": {
 95 |         ".*": {
 96 |             "files_allowed": "data.json",
 97 |             "max_size": 50000,
 98 |             "signers": ["1Abc"]
 99 |         }
100 |     },
101 |     ...
102 | 
103 | We add `signers` to `permission_rules` items! Now, `1Abc` can sign all users' content. And if you move `signers` to a new item, `.*bot@.*`, `1Abc` will be able to sign only `...bot` user content.
104 | 
105 | 
106 | ## Notes
107 | 
108 | ### Note 1
109 | 
110 | From `Db/DbCursor.py` of ZeroNet source code:
111 | 
112 |     def execute(self, query, params=None):
113 |         if isinstance(params, dict) and "?" in query:  # Make easier select and insert by allowing dict params
114 |             if query.startswith("SELECT") or query.startswith("DELETE") or query.startswith("UPDATE"):
115 |                 # Convert param dict to SELECT * FROM table WHERE key = ? AND key2 = ? format
116 |                 query_wheres = []
117 | 
118 | ### Note 2
119 | 
120 | From `Db/DbCursor.py` of ZeroNet source code:
121 | 
122 |     if type(value) is list:
123 |         if key.startswith("not__"):
124 |             query_wheres.append(key.replace("not__", "") + " NOT IN (" + ",".join(["?"] * len(value)) + ")")
125 |         else:
126 |             query_wheres.append(key + " IN (" + ",".join(["?"] * len(value)) + ")")
127 | 


--------------------------------------------------------------------------------
/2. security.md:
--------------------------------------------------------------------------------
 1 | # Security
 2 | 
 3 | This section is about security in ZeroNet. If you are not interested in this or don't understand much, just remember a few things and skip this part.
 4 | 
 5 | - Each zite has a public key and a private key. You access *ZeroHello* by visiting `http://127.0.0.1:43110/1HeLLo4uzjaLetFx6NH3PMwFP3qbRbTf3D/` - here, `1HeLLo4uzjaLetFx6NH3PMwFP3qbRbTf3D` is a public key. Only site owner has private key, and he publishes changes using it.
 6 | - When you want to download a zite, you connect to other peers you know and download zite content from them.
 7 | - No one can change any data on zite without a private key for that zite.
 8 | 
 9 | 
10 | ## Wrong SHA512
11 | 
12 | In ZeroNet, everybody hosts zites, but not all - only the zites they want. For example, if `Windows` hosts `ZeroMe`, and `iPad` wants to download it, `iPad` connects to `Windows` *directly* and says:
13 | 
14 | - **iPad**: Hey, *Windows*, give me `content.json` of `ZeroMe`.
15 | - **Windows**: Here it is: ...
16 | - **iPad**: Thanks! And I also need `index.html`, `js/all.js` and `css/all.css` of `ZeroMe`.
17 | - **Windows**: Here is `index.html`: ... But I have no `js/all.js` and `css/all.css`, sorry.
18 | 
19 | *Windows* gave *iPad* `index.html`, but where can *iPad* find `js/all.js` and `css/all.css`? From other peers *Windows* knows. But the problem is, if *Windows* is malicious, he can only recommend peers that also didn't have those files.
20 | 
21 | - **iPad**: Good bye, *Windows*.
22 | - **iPad**: ...Searching peers...
23 | - **iPad**: Hey, *MacOS*, you have `js/all.js` and `css/all.css` of `ZeroMe`?
24 | - **MacOS**: Of course I have! Here they are: ...
25 | 
26 | But *MacOS* is a hacker! It gives wrong `js/all.js`, with an exploit. Boom! `Windows` has an infected `js/all.js`!
27 | 
28 | ...In fact, no. Each zite has its public key and private key. Public key example is: `1BewKAyyiMZHY3AjQn65J6f6Rcb9p1h64K`. Public key is zite address.
29 | 
30 | In `content.json` of any zite, there is an SHA512 of each files and size of each file. **MacOS** gave **iPad** a file with other SHA512, so **iPad** says:
31 | 
32 | - **iPad**: `css/all.css` is OK. `js/all.js`... isn't.
33 | - **iPad**: ...Adds *MacOS* to black list...
34 | - **iPad**: Good bye, *MacOS*.
35 | - **iPad**: ...Searching peers...
36 | - **iPad**: Hey, *Linux*, you have `js/all.js` of `ZeroMe`?
37 | - **Linux**: Yes. Here it is: ...
38 | - **iPad**: Thanks. Good bye, *Linux*.
39 | 
40 | Now *iPad* has full *ZeroMe* and can show it to you.
41 | 
42 | That's how ZeroNet makes data secure with SHA512.
43 | 
44 | 
45 | ## Wrong `content.json`
46 | 
47 | Now *Linux* needs *ZeroTalk* (its public key is `1TaLkFrMwvbNsooF4ioKAY9EuxTBTjipT`):
48 | 
49 | - **Linux**: You have `content.json` of `1TaLkFrMwvbNsooF4ioKAY9EuxTBTjipT`?
50 | - **MacOS**: Yes. Take it, please: ...
51 | 
52 | As we know, *MacOS* is a hacker. It gives wrong `content.json`, with wrong SHA512. *Linux* would ask *MacOS* for `js/all.js`, and *MacOS* would give *Linux* file with exploit.
53 | 
54 | - **Linux**: Thanks! ...Wait a minute. `content.json` is signed with wrong key.
55 | - **Linux**: ...Adds *MacOS* to black list...
56 | - **Linux**: Good bye, *MacOS*.
57 | 
58 | *Linux* is clever. `content.json` is signed with private key. *MacOS* would have to steal private key or bruteforce it. But the latter is practically impossible. And you shouldn't let anybody steal zite's private key.
59 | 
60 | 
61 | ## Signing
62 | 
63 | Now, we know how data is signed. Only `content.json` is signed, and all other files are signed using `content.json` and its SHA512. It means that nothing can be changed without private key, and usual rainbow tables are useless.
64 | 
65 | 
66 | ## Restricted policy
67 | 
68 | As ZeroNet cannot create a new server for every zite you visit, it creates a single server at `http://127.0.0.1:43110/`. So, some more security is needed. ZeroNet opens every zite in a restricted `<iframe>`, so *localStorage* and some other things can not be used (because some zite would be able to access other zite's data).
69 | 
70 | ZeroNet also does not let zites escape from `<iframe>` - a special token is passed to `<iframe>`, zites use it to communicate with ZeroNet server for some low-level commands. As it changes when you reload the page, bruteforcing `wrapper_nonce` (the token) is the only way to escape `<iframe>`.
71 | 
72 | But how can data be passed to `<iframe>`? Only with query string. So, there is always a `wrapper_nonce` parameter in query string. So, if you expect query string be `?a=2`, in fact it is `?a=2&wrapper_nonce=e0ccdebc9a804cfd8ac9eaf78a4a03054acbd400ce981219037647922219fbcd`.
73 | 
74 | It is, however, possible to run a zite without `<iframe>` wrapper by adding the `/raw/` before the url, eg.: `http://127.0.0.1:43110/raw/1AsRLpuRxr3pb9p3TKoMXPSWHzh6i7fMGi/en.tar.gz/all/index.html`, but this way javascript is disabled by `Content-Security-Policy`.
75 | 


--------------------------------------------------------------------------------
/3. cloning zites.md:
--------------------------------------------------------------------------------
 1 | # Creating zites
 2 | 
 3 | ## Cloning zites
 4 | 
 5 | Let's start with creating a blog for you. Visit *ZeroHello*, download *ZeroBlog* if you haven't downloaded it yet, hover it, and press the epsilon. A menu appears:
 6 | 
 7 | - To favourites
 8 | - Update
 9 | - Check files
10 | - Pause
11 | - Clone
12 | - Delete
13 | 
14 | Press *Clone*. Your new blog appears. That's practically all about cloning.
15 | 
16 | 
17 | ### Changing ZeroBlog
18 | 
19 | You can change blog title, description, etc. by hovering them and pressing a pencil to the left.
20 | 
21 | Now, let's post something. Press *Add new post*. Edit post title, content and press *Sign & Publish new content* button in the bottom. When you sign data, `content.json` is changed. When you publish content, you send other peers that have your zite a new version, they send them to other peers, etc.
22 | 
23 | But now nobody except you have this zite. So, things become difficult. 
24 | 
25 | 
26 | ## Downloading and updating zites
27 | 
28 | When you download a zite, ZeroNet opens your peer list and chooses those which already have this zite. For example, your second computer, which doesn't know about your first computer, wants to download your zite. How to connect these computers?
29 | 
30 | ...Via *trackers*. All peers often connect to trackers in *Internet* and tell them: we are on this IP and have these zites: `...`. So, the first computer tells some tracker about a new zite, and the second computer asks this tracker about anybody having this zite. Easy-peasy.
31 | 
32 | One more word about trackers. You need a static IP or Tor connection to share zites with other peers if these peers don't accept your zite update (for example, they don't have this zite at all).
33 | 
34 | 
35 | ## Proxies
36 | 
37 | Anybody can connect to your blog while there is a running computer (serving your zite). But you probably want to shutdown it at night. So it's a good idea to have a computer always working.
38 | 
39 | Fortunately, there are such computers: *ZeroNet proxies*. [0net.io](https://0net.io) is one of them. You should use them as you use local ZeroNet. On proxies, *ZeroTalk* address is `https://0net.io/1TaLkFrMwvbNsooF4ioKAY9EuxTBTjipT`
40 | 
41 | When your blog is ready, visit `https://0net.io/{zite public key}/`. You can get public key from address bar: `http://127.0.0.1:43110/{zite public key}/`.
42 | 
43 | Available proxies (August 2020): 
44 |  * https://zero.acelewis.com/
45 |  * https://0net-preview.duckdns.org/
46 |  
47 | ## .bit addresses
48 | 
49 | Every zite can be accessed via public key (e.g. `1TaLkFrMwvbNsooF4ioKAY9EuxTBTjipT` for *ZeroTalk*). Hosting such zites takes no price. But you probably don't think `1TaLkFrMwvbNsooF4ioKAY9EuxTBTjipT` is a nice address what if you could have `zerotalk.com`?
50 | 
51 | ...In fact, you can do that via *Namecoin*. *Namecoin* is based on blockchain. If you want to register `.bit` address (for price), you should download a *Namecoin* client and make a `.bit` address there (only `.bit` suffix is supported).
52 | 
53 | If you don't want to host a *Namecoin* client and host the whole blockchain, you can use online services to host domains, such as Dotbit.me and Peername.
54 | 
55 | As majority has *Namecoin* plugin enabled, you can access *ZeroTalk* via `http://127.0.0.1:43110/Talk.ZeroNetwork.bit/`.
56 | 
57 | You can check registered `.bit` addresses at [ZeroName](http://127.0.0.1:43110/zeroname.bit/`).
58 | 
59 | 
60 | ## Homework
61 | 
62 | Try to clone *ZeroTalk* and make your own zite.
63 | 
64 | Todo:
65 | technical clonning explanation
66 | 


--------------------------------------------------------------------------------
/4. creating static zite.md:
--------------------------------------------------------------------------------
  1 | # Creating static zite
  2 | 
  3 | In this part of the tutorial, we are going to create an "About me" zite.
  4 | 
  5 | 
  6 | ## Creating empty zites
  7 | 
  8 | Open *ZeroHello* by starting ZeroNet. Press the epsilon to the right of `Hello ZeroNet_` and choose `Create new, empty site`. Wait a few seconds and a new zite will open.
  9 | 
 10 | You will find something like that:
 11 | 
 12 |     Page address: 1CyNApZ4zp7k3SSXsrW54vEFMHHBpDy3nm
 13 |     - Peers: 1
 14 |     - Size: 5380
 15 |     - Modified: Mon Aug 14 2017 08:14:58 GMT+0300
 16 | 
 17 | - *Page address* is the site's public key.
 18 | - *Peers* is the number of people which your local ZeroNet knows and have your zite. *Peers* should not be used as number of people which visit your zite.
 19 | - *Size* is the size of your zite in bytes.
 20 | 
 21 | 
 22 | ## What's in `index.html`
 23 | 
 24 | Let's open `index.html` of your zite. First of all, let's open ZeroNet home 
 25 | directory:
 26 | 
 27 | - For macOS, that's `~/Application Support/ZeroNet/` or the place where `ZeroNet.app` lives.
 28 | - For Windows, that's the place where ZeroNet was installed (e.g. `C:\Program Files\ZeroNet\`).
 29 | - If you used GIT to install ZeroNet, that's the directory of git repo.
 30 | 
 31 | Now, open `data` directory and then the directory of your zite address (from the page ZeroNet opened, e.g. `1CyNApZ4zp7k3SSXsrW54vEFMHHBpDy3nm`). All the other directories are your local copies of other zites.
 32 | 
 33 | Let's open `index.html`:
 34 | 
 35 |     <!DOCTYPE html>
 36 |     
 37 |     <html>
 38 |     <head>
 39 |      <title>New ZeroNet site!</title>
 40 |      <meta charset="utf-8">
 41 |      <meta http-equiv="content-type" content="text/html; charset=utf-8" />
 42 |      <base href="" target="_top" id="base">
 43 |      <script>base.href = document.location.href.replace("/media", "").replace("index.html", "").replace(/[&?]wrapper=False/, "").replace(/[&?]wrapper_nonce=[A-Za-z0-9]+/, "")</script>
 44 |     </head>
 45 |     <body>
 46 |         
 47 |     <div id="out"></div>
 48 |     
 49 |     <script type="text/javascript" src="js/ZeroFrame.js"></script>
 50 |     <script>
 51 |         
 52 |     class Page extends ZeroFrame {
 53 |         setSiteInfo(site_info) {
 54 |             var out = document.getElementById("out")
 55 |             out.innerHTML =
 56 |                 "Page address: " + site_info.address +
 57 |                 "<br>- Peers: " + site_info.peers +
 58 |                 "<br>- Size: " + site_info.settings.size +
 59 |                 "<br>- Modified: " + (new Date(site_info.content.modified*1000))
 60 |         }
 61 |         
 62 |         onOpenWebsocket() {
 63 |             this.cmd("siteInfo", [], function(site_info) {
 64 |                 page.setSiteInfo(site_info)
 65 |             })
 66 |         }
 67 |         
 68 |         onRequest(cmd, message) {
 69 |             if (cmd == "setSiteInfo")
 70 |                 this.setSiteInfo(message.params)
 71 |             else
 72 |                 this.log("Unknown incoming message:", cmd)
 73 |         }
 74 |     }
 75 |     page = new Page()
 76 |     </script>
 77 |     
 78 |     </body>
 79 |     </html>
 80 | 
 81 | It's not easy to understand what's happening here, but that's not needed. Let's delete something and show what happens.
 82 | 
 83 | 
 84 |     <!DOCTYPE html>
 85 |     
 86 |     <html>
 87 |     <head>
 88 |      <title>New ZeroNet site!</title>
 89 |      <meta charset="utf-8">
 90 |      <meta http-equiv="content-type" content="text/html; charset=utf-8" />
 91 |      <base href="" target="_top" id="base">
 92 |      <script>base.href = document.location.href.replace("/media", "").replace("index.html", "").replace(/[&?]wrapper=False/, "").replace(/[&?]wrapper_nonce=[A-Za-z0-9]+/, "")</script>
 93 |     </head>
 94 |     <body>
 95 |     </body>
 96 |     </html>
 97 | 
 98 | That's much better. We removed a useless (for us) script. Now let's reindent this.
 99 | 
100 | 
101 |     <!DOCTYPE html>
102 |     <html>
103 |         <head>
104 |             <title>New ZeroNet site!</title>
105 |             <meta charset="utf-8">
106 |             <meta http-equiv="content-type" content="text/html; charset=utf-8" />
107 |             <base href="" target="_top" id="base">
108 |             <script>
109 |                 base.href = document.location.href.replace("/media", "").replace("index.html", "").replace(/[&?]wrapper=False/, "").replace(/[&?]wrapper_nonce=[A-Za-z0-9]+/, "")
110 |             </script>
111 |         </head>
112 |         <body>
113 |         </body>
114 |     </html>
115 | 
116 | Even better. **You may change anything espect `<base>` and the following `<script>` tag.** Each zite you visit runs in a restricted `<iframe>`, so some things like *localStorage* are not possible. I'll tell you how to bypass that in the following part of the tutorial.
117 | 
118 | You shouldn't also remove `js/ZeroFrame.js` file. It may not be needed for this zite, but practically all other ZeroNet sites use it.
119 | 
120 | 
121 | ## Tips
122 | 
123 | ### Disabling caching
124 | 
125 | When you edit files, you may not notice updates in browser. That is because of caching. There should be an option to disable this while *DevTools* is open. *DevTools* has to be open while zite developing then.
126 | 
127 | - In Firefox, open *DevTools* by pressing F12, click Settings icon in the top right corner of the window, and choose `Disable HTTP cache (while DevTools is open)`.
128 | - In Chrome, open *DevTools* by pressing F12, now press F1, click *Preferences* in the left navigation bar and choose `Disable cache (while DevTools is open)` from *Network* menu.
129 | 
130 | 
131 | ### Absolute paths don't work
132 | 
133 | Let's make some `<div>`s and style them.
134 | 
135 | First, add `<div>1</div>` to `index.html`. A `1` appears.
136 | 
137 | 
138 | Now, let's create `css/index.css` with the following content:
139 | 
140 |     div {
141 |         color: red;
142 |     }
143 | 
144 | ...and include it in `index.html`:
145 | 
146 |     <link rel="stylesheet" href="/css/index.css" type="text/css">
147 | 
148 | Nothing changes. But why?.. Because of zite address: `http://127.0.0.1:43110/1CyNApZ4zp7k3SSXsrW54vEFMHHBpDy3nm/`. So `/css/index.css` gets calculated as `http://127.0.0.1:43110/css/index.css`. So, using absolute paths is not allowed in ZeroNet. So, we change `<link>` to:
149 | 
150 |     <link rel="stylesheet" href="css/index.css" type="text/css">
151 | 
152 | 
153 | ### `<iframe>`s don't work
154 | 
155 | Each page you open in ZeroNet has the following code:
156 | 
157 |     <script>
158 |     // If we are inside iframe escape from it
159 |     if (window.self !== window.top) window.open(window.location.toString(), "_top");
160 |     if (window.self !== window.top) window.stop();
161 |     if (window.self !== window.top && document.execCommand) document.execCommand("Stop", false)
162 |     </script>
163 | 
164 | So, you cannot `<iframe>` other ZeroNet pages, including other HTML files of your site.
165 | 
166 | 
167 | ## Design
168 | 
169 | I'll leave design to you. You can download the final version of my site from [downloads](downloads/porfolio.zip).
170 | 
171 | 
172 | ## Site settings
173 | 
174 | To change site description and title, we have to use sidebar. Have you noticed `0` button in the top right corner? Clicking it returns you to *ZeroHello*. Now drag it to the left:
175 | 
176 |       _____              _____  
177 |      /     \            /     \ 
178 |     |   0   | <------- |   0   |
179 |      \_____/            \_____/ 
180 | 
181 | 
182 | The sidebar will appear. You can see connected peers, files, database info (we'll cover it later), your unique address (it changes when you login *ZeroID* or *KaffieID* or *CryptoID*). You can also change site info if you are the owner.
183 | 
184 | Scroll to the bottom and change `Site title` and `Site description` parameters. Press `Save site settings`. Now the settings are saved in `content.json`. Have you noticed that file in the root of your zite? It holds all information about your zite, including files and settings.
185 | 
186 | Now let's publish your zite. First, press `Sign` button in the very bottom of the sidebar. Your `content.json` now holds updated information about files and is signed correctly. Now press `Publish`. You will probably see `Content publish failed` message. That's OK, as no other peers have downloaded your zite.
187 | 
188 | Now, if you have a static IP or Tor mode is on, your zite can be accessed from other peers while your computer is on. If you want to turn your computer down, visit `0net.io`: `https://0net.io/{zite public key}/` (You can get public key from address bar of from sidebar).
189 | Available proxies: [0net.io](https://0net.io), [@amorgan's proxy](http://zn.amorgan.xyz) and [ZeroGate](https://zerogate.tk).
190 | 
191 | 
192 | ## .bit address
193 | 
194 | If you really want to have a nice domain like `ivanq.bit`, use *Namecoin*. I won't cover this, but there are many tutorials in Internet and ZeroNet about it.
195 | 


--------------------------------------------------------------------------------
/5. zeroframe.md:
--------------------------------------------------------------------------------
  1 | # ZeroFrame
  2 | 
  3 | In the previous part, I told you that *localStorage* and some other features are disabled. In this section, I will tell you how to bypass it.
  4 | 
  5 | 
  6 | ## WebSockets
  7 | 
  8 | To let sites read and write files, change *localStorage*, sign data, etc. ZeroNet uses WebSockets. *ZeroFrame* does all dirty work for you. Remember `js/ZeroFrame.js` I told you not to remove in the previous part? That's API interface.
  9 | 
 10 | 
 11 | ## Installing ZeroFrame
 12 | 
 13 | First, let's create a new, really empty zite. Use *ZeroHello* to do this. Now open ZeroNet home directory, then data, now zite public key.
 14 | 
 15 | Change `index.html` to:
 16 | 
 17 |     <!DOCTYPE html>
 18 |     <html>
 19 |         <head>
 20 |             <title></title>
 21 |             <meta charset="utf-8">
 22 |             <meta http-equiv="content-type" content="text/html; charset=utf-8" />
 23 |             <base href="" target="_top" id="base">
 24 |             <script>
 25 |                 base.href = document.location.href.replace("/media", "").replace("index.html", "").replace(/[&?]wrapper=False/, "").replace(/[&?]wrapper_nonce=[A-Za-z0-9]+/, "")
 26 |             </script>
 27 |         </head>
 28 |         <body>
 29 |         </body>
 30 |     </html>
 31 | 
 32 | I have just removed useless (now) `<script>` from `<body>` and indented code.
 33 | 
 34 | 
 35 | Let's include `js/ZeroFrame.js` and create empty `js/index.js`:
 36 | 
 37 |     <!DOCTYPE html>
 38 |     <html>
 39 |         <head>
 40 |             <title></title>
 41 |             <meta charset="utf-8">
 42 |             <meta http-equiv="content-type" content="text/html; charset=utf-8" />
 43 |             <base href="" target="_top" id="base">
 44 |             <script>
 45 |                 base.href = document.location.href.replace("/media", "").replace("index.html", "").replace(/[&?]wrapper=False/, "").replace(/[&?]wrapper_nonce=[A-Za-z0-9]+/, "")
 46 |             </script>
 47 |         </head>
 48 |         <body>
 49 |             <script type="text/javascript" src="js/ZeroFrame.js"></script>
 50 |             <script type="text/javascript" src="js/index.js"></script>
 51 |         </body>
 52 |     </html>
 53 | 
 54 | 
 55 | Open and edit `js/index.js`:
 56 | 
 57 |     var zeroFrame = new ZeroFrame();
 58 |     console.log(zeroFrame);
 59 | 
 60 | 
 61 | Open *DevTools Console* and reload page. You'll notice:
 62 | 
 63 |     Object { url: undefined, waiting_cb: Object, wrapper_nonce: "45be457a20334e09dbda338264976328d1f…", target: Object → 1CyNApZ4zp7k3SSXsrW54vEFMHHBpDy3nm, next_message_id: 1 }
 64 | 
 65 | ...or something like that. That's *ZeroFrame* - a receiver and a transmitter, the thing all ZeroNet was created of.
 66 | 
 67 | 
 68 | ## First API call
 69 | 
 70 | The main function of ZeroFrame is `ZeroFrame.prototype.cmd()`. Let's try to get site info.
 71 | 
 72 |     var zeroFrame = new ZeroFrame();
 73 |     zeroFrame.cmd("siteInfo", [], function(info) {
 74 |         console.log(info);
 75 |     });
 76 | 
 77 | We already know first line. By the way, you must not create two ZeroFrame's. The rest of file call ZeroNet API. The first argument is API method - here it's `siteInfo`. The second argument is parameters - it is optional, so we could remove `, []` from this code. The third argument is callback.
 78 | 
 79 | Reload page and watch console. You'll find something like:
 80 | 
 81 |     Object { tasks: 0, size_limit: 10, address: "1CyNApZ4zp7k3SSXsrW54vEFMHHBpDy3nm", next_size_limit: 10, auth_address: "1E3sYXHq99vXW5hS3M9PhQzQhpmWx1paHu", feed_follow_num: null, content: Object, peers: 1, auth_key: "db87a590a113015ddf1b2c73f96baacaa097eee1747d71bdbe5748073bc6131b", settings: Object, 6 more... }
 82 | 
 83 | 
 84 | One of the problems of ZeroFrame is its callback nature which results in callback hell. I think that promise hell is better, moreover, promises are compatible with async/await. If you want to use callbacks, use ZeroFrame. If you want to use promises or async/await (the latter is not supported by ZeroNet, but you can use Babel), use my *ZeroPage library* (you can find documentation in extra lessons and download it [here](downloads/ZeroPage.js). I will show how to do that with ZeroFrame, but you can find both versions of resulting zite [here](downloads/notepad.html).
 85 | 
 86 | *UPD. In new versions of ZeroHello (sites are in fact created by it) `ZeroFrame.prototype.cmdp()` function was added. It returns a promise, which rejects if result has `error` property and resolves . However, I can still recommend my library because you don't have to write much code for simple things.*
 87 | 
 88 | 
 89 | ## File system
 90 | 
 91 | ZeroFrame allows you to read and write files inside zite directory. The API methods are:
 92 | 
 93 |     +-------------------------------------------------------------------------+
 94 |     |                                 fileGet                                 |
 95 |     +-------------------------------------------------------------------------+
 96 |     | Get file content                                                        |
 97 |     +-------------------------+-----------------------------------------------+
 98 |     | Parameter               | Description                                   |
 99 |     +-------------------------+-----------------------------------------------+
100 |     | inner_path              | The file you want to get                      |
101 |     | required (optional)     | Try and wait for the file if it's not exists. |
102 |     |                         | (default: True)                               |
103 |     | format (optional)       | Encoding of returned data. (text or base64)   |
104 |     |                         | (default: text)                               |
105 |     | timeout (optional)      | Maximum wait time to data arrive              |
106 |     |                         | (default: 300)                                |
107 |     +-------------------------+-----------------------------------------------+
108 |     | Return: The content of the file or null or undefined (I don't           |
109 |     | understand the difference between the latter two)                       |
110 |     +-------------------------------------------------------------------------+
111 |     
112 |     +-------------------------------------------------------------------------+
113 |     |                                fileWrite                                |
114 |     +-------------------------------------------------------------------------+
115 |     | Write file content                                                      |
116 |     +-------------------------+-----------------------------------------------+
117 |     | Parameter               | Description                                   |
118 |     +-------------------------+-----------------------------------------------+
119 |     | inner_path              | Inner path of the file you want to write      |
120 |     | content_base64          | Content you want to write to file (base64     |
121 |     |                         | encoded)                                      |
122 |     +-------------------------+-----------------------------------------------+
123 |     | Return: "ok" or error message                                           |
124 |     +-------------------------------------------------------------------------+
125 | 
126 | If you choosed to use my *ZeroPage* library, I also have *ZeroFS*. You can download it [here](downloads/ZeroFS.js).
127 | 
128 | 
129 | Let's change `index.js` content to:
130 | 
131 |     var zeroFrame = new ZeroFrame();
132 |     
133 |     function readFile(file, callback) {
134 |         ...
135 |     }
136 |     function writeFile(file, content, callback) {
137 |         ...
138 |     }
139 | 
140 | 
141 | ### Reading files
142 | 
143 | Before reading the answer, try to write `readFile()` yourself. Ready?
144 | 
145 |     function readFile(file, callback) {
146 |         zeroFrame.cmd("fileGet", [file, false], callback);
147 |     }
148 | 
149 | 
150 | By the way, you could write:
151 | 
152 |     function readFile(file, callback) {
153 |         zeroFrame.cmd("fileGet", {
154 |             inner_path: file,
155 |             required: false
156 |         }, callback);
157 |     }
158 | 
159 | ...because parameters may be either ommited or array or object (notice parameter names in method documentation).
160 | 
161 | If you set `required` to `true`, then everything will still work, but a warning will appear.
162 | 
163 | 
164 | ### Writing files
165 | 
166 | `writeFile()` is complex. I would say, complicated. Input should be Base64, so you could write:
167 | 
168 |     function writeFile(file, content, callback) {
169 |         zeroFrame.cmd("fileWrite", [file, btoa(content)], callback);
170 |     }
171 | 
172 | But `btoa()` doesn't work with UTF8. So we will write another function:
173 | 
174 |     function base64Encode(content) {
175 |         content = encodeURIComponent(content); // Split to bytes in % notation
176 |         content = unescape(content); // Join % notation as bytes (not as chars)
177 |         return btoa(content);
178 |     }
179 | 
180 | ...and use it instead of `btoa()` in `writeFile()`.
181 | 
182 | 
183 | So, we convert UTF8 to bytes. But what if `content` is just byte string? Then, `encodeURIComponent` - `unescape` pair will break bytes because Unicode has multiple codes for several chars. So, we will add another function which uses `btoa()` instead of `base64Encode` (take `writeFile()` and code `writeBinaryFile()` yourself).
184 | 
185 | Our filesystem library is finished. Well, only file part, but that's enough for now. You can either read my *ZeroFS* library to understand directory part or read documentation here or at [this mirror](/1HP65eGEEMPbyzH3mkaoQ7eCMKd9P8G61W/).
186 | 
187 | 
188 | ## Notepad
189 | 
190 | The simpliest program which uses file API is probably text editor. Try to write it yourself. Then try to understand my code from [download section](download/notepad.html).
191 | 
192 | 
193 | ## Tips
194 | 
195 | You *can* write `animate()` function each time you need it, but you shouldn't do that. You should save it to some file and copy-paste it when you need it.
196 | 
197 | The same is true with ZeroNet. There are always problems with it (it's Beta). And sometimes you don't understand why something doesn't work (it took 2 months for me to make databases work - because of lack of documentation I had to read source code). So, feel free to contact me here or at [ZeroMail](/1MaiL5gfBM1cyb4a8e3iiL8L5gXmoAJu27/?to=ivanq).
198 | 


--------------------------------------------------------------------------------
/6. databases.md:
--------------------------------------------------------------------------------
  1 | # Creating databases
  2 | 
  3 | Today we are going to write a blog. Your own blog with your own design.
  4 | 
  5 | 
  6 | ## Creating zite
  7 | 
  8 | First of all, I recommend creating a new, empty site (in my case, `1CyNApZ4zp7k3SSXsrW54vEFMHHBpDy3nm`), because it can be a bit difficult to repair a site from incorrect database. As usual, I will give you the code in two formats: with plain ZeroFrame and with my library (I believe the latter is better).
  9 | 
 10 | 
 11 | ## Overview
 12 | 
 13 | ZeroNet has builtin database, *SQLite*. Of course, you can create your own DB using files, but this is not serious. Let's begin with creating our database.
 14 | 
 15 | 
 16 | ## Database source
 17 | 
 18 | In ZeroNet, only SQL *SELECT* is allowed. Database is created from JSON files. Let's create one of these files right now.
 19 | 
 20 | 
 21 | ### `data.json`
 22 | 
 23 | By tradition, tables are held in `data/*/data.json` files. Let's create `data/admin/data.json` now. Create an array, `posts`, with rows inside it.
 24 | 
 25 |     {
 26 |         "posts": [
 27 |             {
 28 |                 "id": 1,
 29 |                 "title": "Post 1",
 30 |                 "content": "Post 1"
 31 |             },
 32 |             {
 33 |                 "id": 2,
 34 |                 "title": "Post 2",
 35 |                 "content": "Post 2"
 36 |             }
 37 |         ]
 38 |     }
 39 | 
 40 | 
 41 | ## Dbschema format
 42 | 
 43 | `dbschema.json` is a simple JSON file. This is empty DB:
 44 | 
 45 |     {
 46 |         "db_name": "mydatabase",
 47 |         "db_file": "data/mydatabase.db",
 48 |         "version": 2,
 49 |         "maps": {},
 50 |         "tables": {}
 51 |     }
 52 | 
 53 | - `db_name` parameter is database name, but it is used only for debug. You cannot have more that one database per site.
 54 | - *SQLite* database is only one file, and `db_file` is its path.
 55 | - `version` is database, not *SQLite* version. We'll talk about it later.
 56 | - `maps` object sets relationship between database and files.
 57 | - `tables` object sets table structure.
 58 | 
 59 | Please copy this empty DB to `dbschema.json` file in the root of your site.
 60 | 
 61 | 
 62 | ### `json` table
 63 | 
 64 | For each registered user (administrator or simple ZeroID user), a row is created in `json` table. Sadly, ZeroNet doesn't work without this table. We'll talk about it's contents later. Now, let's just add such table.
 65 | 
 66 | `dbschema.json`:
 67 | 
 68 |     {
 69 |         "db_name": "mydatabase",
 70 |         "db_file": "data/mydatabase.db",
 71 |         "version": 2,
 72 |         "maps": {},
 73 |         "tables": {
 74 |             "json": {
 75 |                 "cols": [
 76 |                     ["json_id", "INTEGER PRIMARY KEY AUTOINCREMENT"],
 77 |                     ["directory", "TEXT"],
 78 |                     ["file_name", "TEXT"]
 79 |                 ],
 80 |                 "indexes": ["CREATE UNIQUE INDEX path ON json(directory, file_name)"],
 81 |                 "schema_changed": 1
 82 |             }
 83 |         }
 84 |     }
 85 | 
 86 | 
 87 | ### Adding tables
 88 | 
 89 | Let's add `posts` table from our `data/admin/data.json` file.
 90 | 
 91 | First, let's set table name.
 92 | 
 93 |     {
 94 |         "db_name": "mydatabase",
 95 |         "db_file": "data/mydatabase.db",
 96 |         "version": 2,
 97 |         "maps": {},
 98 |         "tables": {
 99 |             "json": {
100 |                 "cols": [
101 |                     ["json_id", "INTEGER PRIMARY KEY AUTOINCREMENT"],
102 |                     ["directory", "TEXT"],
103 |                     ["file_name", "TEXT"]
104 |                 ],
105 |                 "indexes": ["CREATE UNIQUE INDEX path ON json(directory, file_name)"],
106 |                 "schema_changed": 1
107 |             },
108 |             "posts": {
109 |                 ...
110 |             }
111 |         }
112 |     }
113 | 
114 | 
115 | As you can see from `json` table specification, each table consists of `cols`, `indexes` and `schema_changed`. `schema_changed` is simply table version. Increment it once you change table structure, so that other peers recreate this table.
116 | 
117 |     "posts": {
118 |         "cols": [
119 |             ...
120 |         ],
121 |         "indexes": [
122 |             ...
123 |         ],
124 |         "schema_changed": 1
125 |     }
126 | 
127 | 
128 | `cols` is column array. First entry of each column is column name (SQL keywords, such as `GROUP` and `UPDATE` are not allowed). Second entry of each column is *SQLite* column type - `integer`, `float` or `text`.
129 | 
130 |     "posts": {
131 |         "cols": [
132 |             ["id", "integer"],
133 |             ["title", "text"],
134 |             ["content", "text"],
135 |             ["json_id", "integer references json(json_id)"]
136 |         ],
137 |         "indexes": [
138 |             ...
139 |         ],
140 |         "schema_changed": 1
141 |     }
142 | 
143 | See that `json_id` column? That's another strange thing in `dbschema.json`. Each table must have such column with such type.
144 | 
145 | 
146 | `indexes` is index array. Any `CREATE INDEX` SQL command can be there. Index name doesn't mean anything.
147 | 
148 |     "posts": {
149 |         "cols": [
150 |             ["id", "integer"],
151 |             ["title", "text"],
152 |             ["content", "text"],
153 |             ["json_id", "integer references json(json_id)"]
154 |         ],
155 |         "indexes": [
156 |             "CREATE UNIQUE INDEX post_id ON posts(id)"
157 |         ],
158 |         "schema_changed": 1
159 |     }
160 | 
161 | 
162 | Now, we have a DB. Right now, sign `content.json`. You'll find a new file, `data/mydatabase.db` (from `db_file` property of `dbschema.json`). This is *SQLite* database. I recommend *SQLiteStudio* for browsing these files. Right now, you'll find empty `json` and `post` tables, and a special `keyvalue` table. This is ZeroNet internal table, usually we don't need to touch it.
163 | 
164 | 
165 | ### Mapping tables
166 | 
167 | #### `to_table`
168 | 
169 | We have an empty table with correct structure. But who needs empty tables? Let's fill `posts` table from `data/admin/data.json`.
170 | 
171 | Remember empty `maps` object from `dbschema.json`?
172 | 
173 |     ...
174 |     "version": 2,
175 |     "maps": {},
176 |     "tables": {
177 |         ...
178 | 
179 | 
180 | Let's change it.
181 | 
182 |     "maps": {
183 |         "admin/data.json": {
184 |             "to_table": [
185 |                 {
186 |                     "node": "posts",
187 |                     "table": "posts"
188 |                 }
189 |             ]
190 |         }
191 |     }
192 | 
193 | Object name `admin/data.json` is *regular expression*. Each file that matches this expression is checked against object value. Right now you can see only `to_table` property. That means that each row from `posts` object in any file that matches *regular expression* (`admin/data.json`) is added to `posts` table.
194 | 
195 | 
196 | Let's sign `content.json` and check database content again. See that `json_id` column in `posts` table? And that row in `json` table? That's OK. `json_id` in `posts` table maps to `json_id` in `json` table. And from `json` table we know, which file added a row. You probably think that's not necessary, but that's not necessary only right now.
197 | 
198 | 
199 | ## Read access to database
200 | 
201 | Let's start writing code. Create empty `js/index.js`. Include it and `js/ZeroFrame.js` to `index.html`.
202 | 
203 | Remember how to call ZeroFrame? Let's call `dbQuery`:
204 | 
205 |     +-------------------------------------------------------------------------+
206 |     |                                 dbQuery                                 |
207 |     +-------------------------------------------------------------------------+
208 |     | Run a query on the sql cache                                            |
209 |     +-------------------------+-----------------------------------------------+
210 |     | Parameter               | Description                                   |
211 |     +-------------------------+-----------------------------------------------+
212 |     | query                   | Sql query command                             |
213 |     +-------------------------+-----------------------------------------------+
214 |     | Return: Result of query as array or object with "error" property        |
215 |     +-------------------------------------------------------------------------+
216 | 
217 |     var zeroFrame = new ZeroFrame();
218 |     
219 |     zeroFrame.cmd("dbQuery", ["SELECT * FROM posts"], function(posts) {
220 |         if(posts.error) {
221 |             console.warn(posts.error);
222 |             return;
223 |         }
224 |         
225 |         console.log(posts);
226 |     });
227 | 
228 | Open console, reload page, and you'll see the following:
229 | 
230 |     Array [ Object, Object ]
231 |             Object {
232 |                 content: "Post 1",
233 |                 id: 1,
234 |                 json_id: 1,
235 |                 title: "Post 1"
236 |             }
237 | 
238 | 
239 | We'll cover dynamic data changing and design in the following parts. For now, you can directly change `data/admin/data.json`, sign `content.json` and reload zite to see what changes.
240 | 


--------------------------------------------------------------------------------
/7. changing tables.md:
--------------------------------------------------------------------------------
  1 | # Changing tables
  2 | 
  3 | In this section, we will cover write access to *SQLite*.
  4 | 
  5 | 
  6 | ## Auto increment
  7 | 
  8 | Now we want to add a new post. But where can we take ID from? There is a nice answer. Let's add a new property to `data/admin/data.json`:
  9 | 
 10 |     {
 11 |         "next_post_id": 3,
 12 |         "posts": [
 13 |             {
 14 |                 "id": 1,
 15 |                 "title": "Post 1",
 16 |                 "content": "Post 1"
 17 |             },
 18 |             {
 19 |                 "id": 2,
 20 |                 "title": "Post 2",
 21 |                 "content": "Post 2"
 22 |             }
 23 |         ]
 24 |     }
 25 | 
 26 | Most zites use this way: they add `next_..._id`. We'll do the same. When we add new post, we will take id from `next_post_id` and increment the latter.
 27 | 
 28 | 
 29 | ## Write access to database
 30 | 
 31 | As I told you before, only *SELECT* is supported. Remember where we edited posts? Yes, in `data/admin/data.json` file. So, let's take our `readFile()` and `writeFile()` functions from the previous lesson:
 32 | 
 33 |     function readFile(file, callback) {
 34 |         zeroFrame.cmd("fileGet", [file, false], callback);
 35 |     }
 36 |     
 37 |     function writeFile(file, content, callback) {
 38 |         zeroFrame.cmd("fileWrite", [file, base64Encode(content)], callback);
 39 |     }
 40 |     
 41 |     function base64Encode(content) {
 42 |         content = encodeURIComponent(content); // Split to bytes in % notation
 43 |         content = unescape(content); // Join % notation as bytes (not as chars)
 44 |         return btoa(content);
 45 |     }
 46 | 
 47 | ...and put them to `js/files.js`. Don't forget to include this file to `index.html` before `index.js`:
 48 | 
 49 |     <script type="text/javascript" src="js/files.js"></script>
 50 | 
 51 | 
 52 | First of all, let's read `data/admin/data.json` and parse it. Try to do that yourself.
 53 | 
 54 | Answer:
 55 | 
 56 |     function addPost(title, postContent) {
 57 |         readFile("data/admin/data.json", function(content) {
 58 |             content = content || ""; // Convert undefined and null to ""
 59 |             
 60 |             // Parse JSON
 61 |             try {
 62 |                 content = JSON.parse(content);
 63 |             } catch(e) {
 64 |                 content = {
 65 |                     posts: [],
 66 |                     next_post_id: 0
 67 |                 };
 68 |             }
 69 |             
 70 |             console.log(content);
 71 |         });
 72 |     }
 73 |     
 74 |     addPost("test", "test content");
 75 | 
 76 | Open console and reload page. You'll see an object with `posts` and `next_post_id` properties.
 77 | 
 78 | 
 79 | Now, we can simply take `next_post_id` and change `posts` array:
 80 | 
 81 |     function addPost(title, postContent, callback) { // Notice new callback argument
 82 |         readFile("data/admin/data.json", function(content) {
 83 |             ...
 84 |             // Parse JSON
 85 |             ...
 86 |             
 87 |             content.posts.push({
 88 |                 id: content.next_post_id++, // Use next_post_id and then increment it
 89 |                 title: title,
 90 |                 content: postContent
 91 |             });
 92 |             
 93 |             content = JSON.stringify(content, null, 4); // Make content string
 94 |             
 95 |             writeFile("data/admin/data.json", content, function(result) {
 96 |                 callback(result == "ok");
 97 |             });
 98 |         });
 99 |     }
100 |     
101 |     addPost("test", "test content", function(result) {
102 |         console.log(result ? "OK" : "Error");
103 |     });
104 | 
105 | Try to run this code and see how `data/admin/data.json` changes. Now open `data/mydatabase.db`. Only old posts, right? That's because we have to sign and publish our changes after changing data. Here are API commands we need:
106 | 
107 |     +-------------------------------------------------------------------------+
108 |     |                                siteSign                                 |
109 |     +-------------------------------------------------------------------------+
110 |     | Sign a content.json of the site                                         |
111 |     +-------------------------+-----------------------------------------------+
112 |     | Parameter               | Description                                   |
113 |     +-------------------------+-----------------------------------------------+
114 |     | privatekey (optional)   | Private key used for signing (default:        |
115 |     |                         | current user's privatekey). "stored" means    |
116 |     |                         | saved site private key                        |
117 |     +-------------------------+-----------------------------------------------+
118 |     | inner_path (optional)   | Inner path of the content json you want to    |
119 |     |                         | sign (default: content.json)                  |
120 |     +-------------------------+-----------------------------------------------+
121 |     | Return: "ok" on success else the error message                          |
122 |     +-------------------------------------------------------------------------+
123 |     
124 |     +-------------------------------------------------------------------------+
125 |     |                               sitePublish                               |
126 |     +-------------------------------------------------------------------------+
127 |     | Publish a content.json of the site                                      |
128 |     +-------------------------+-----------------------------------------------+
129 |     | Parameter               | Description                                   |
130 |     +-------------------------+-----------------------------------------------+
131 |     | privatekey (optional)   | Private key used for signing (default:        |
132 |     |                         | current user's privatekey). "stored" means    |
133 |     |                         | saved zite private key                        |
134 |     +-------------------------+-----------------------------------------------+
135 |     | inner_path (optional)   | Inner path of the content json you want to    |
136 |     |                         | publish (default: content.json)               |
137 |     +-------------------------+-----------------------------------------------+
138 |     | sign (optional)         | If True then sign the content.json before     |
139 |     |                         | publish (default: True)                       |
140 |     +-------------------------+-----------------------------------------------+
141 |     | Return: "ok" on success else the error message                          |
142 |     +-------------------------------------------------------------------------+
143 | 
144 | We want to both sign and publish zite, so we can use `sitePublish` with `sign` option:
145 | 
146 |     writeFile("data/admin/data.json", content, function(result) {
147 |         if(result != "ok") {
148 |             callback(false);
149 |             return;
150 |         }
151 |         
152 |         zeroFrame.cmd("sitePublish", {
153 |             privatekey: "stored"
154 |         }, function(result) {
155 |             callback(result == "ok");
156 |         });
157 |     });
158 | 
159 | Try to reload page multiple times and open `data/mydatabase.db`.
160 | 
161 | 
162 | ## Private key
163 | 
164 | The main thing in `siteSign` and `sitePublish` commands is `privatekey` option. It is not logical at all, but as it is used frequently, you have to remember its meaning.
165 | 
166 | - `privatekey: null` means "use private key which ZeroNet created especially for this zite and especially for this user". Some sites (like ZeroTalk) have user content (posts and votes). To sign this data with user's private key, they don't pass `privatekey` option at all or set it to `null`.
167 | - `privatekey: "stored"` means "use private key of zite". This can be used only if user is zite administrator.
168 | - `privatekey: "..."` means "use this private key".
169 | 
170 | 
171 | ## Permissions
172 | 
173 | We also often want to know if user is administrator. For example, for a blog, we should show "Add" button only if user can write to `data/admin/data.json`. ZeroFrame to rescue! We can use `siteInfo` command. It returns a JSON object with `privatekey` boolean - it is true if current user is administrator.
174 | 
175 |     function isAdmin(callback) {
176 |         zeroFrame.cmd("siteInfo", [], function(info) {
177 |             callback(!!info.privatekey);
178 |         });
179 |     }
180 | 
181 | 
182 | ## Example
183 | 
184 | You can watch blog example [here](downloads/blog.html).
185 | 
186 | Some ideas for improvements:
187 | 
188 | - Add option to delete post.
189 | - More beautiful editing page.
190 | - Delete created post when `Cancel` is clicked on `Add post` page.
191 | - Use markup language different from HTML.
192 | 


--------------------------------------------------------------------------------
/8. dbschema.md:
--------------------------------------------------------------------------------
  1 | # Dbschema. We need to go deeper
  2 | 
  3 | Today let's speak about some improvements in `dbschema.json`.
  4 | 
  5 | Let's use this `dbschema.json`:
  6 | 
  7 |     {
  8 |         "db_name": "mydatabase",
  9 |         "db_file": "data/mydatabase.db",
 10 |         "version": 2,
 11 |         "maps": {
 12 |             "admin/data.json": {
 13 |                 "to_table": [
 14 |                     {
 15 |                         "node": "posts",
 16 |                         "table": "posts"
 17 |                     }
 18 |                 ]
 19 |             }
 20 |         },
 21 |         "tables": {
 22 |             "json": {
 23 |                 "cols": [
 24 |                     ["json_id", "INTEGER PRIMARY KEY AUTOINCREMENT"],
 25 |                     ["directory", "TEXT"],
 26 |                     ["file_name", "TEXT"]
 27 |                 ],
 28 |                 "indexes": ["CREATE UNIQUE INDEX path ON json(directory, file_name)"],
 29 |                 "schema_changed": 1
 30 |             },
 31 |             "posts": {
 32 |                 "cols": [
 33 |                     ["id", "integer"],
 34 |                     ["content", "text"],
 35 |                     ["json_id", "integer references json(json_id)"]
 36 |                 ],
 37 |                 "indexes": [
 38 |                     "CREATE UNIQUE INDEX post_id ON posts(id)"
 39 |                 ],
 40 |                 "schema_changed": 1
 41 |             }
 42 |         }
 43 |     }
 44 | 
 45 | So, we have a `posts` table with `id` and `content` columns. And we get it from `posts` table in `data/admin/data.json`.
 46 | 
 47 | 
 48 | ## `key_col`
 49 | 
 50 | Think about unique columns. Like votes - the pair `id` and `author_id` is unique. Or simple `id` in our `posts` table. But how can we add unique columns if data is loaded from JSON arrays, and there is no unique data in JSON? Or is there?..
 51 | 
 52 | Yes, there is. Remember objects? Keys are unique. So, let's make a unique column a key. Post ID, for example.
 53 | 
 54 | 
 55 | In `data/admin/data.json`, we change array to object and move ID to property key.
 56 | 
 57 |     {
 58 |         "posts": {
 59 |             "1": {
 60 |                 "content": "Post 1"
 61 |             },
 62 |             "2": {
 63 |                 "content": "Post 2"
 64 |             }
 65 |         }
 66 |     }
 67 | 
 68 | 
 69 | In `dbschema.json`, we added `key_col` property. We told ZeroNet that property key should be `id` column.
 70 | 
 71 |     "maps": {
 72 |         "admin/data.json": {
 73 |             "to_table": [
 74 |                 {
 75 |                     "node": "posts",
 76 |                     "table": "posts",
 77 |                     "key_col": "id"
 78 |                 }
 79 |             ]
 80 |         }
 81 |     }
 82 | 
 83 | 
 84 | Sign `content.json` and open `data/mydatabase.db`. Nothing was changed, but now `id` column is always unique - simply because of JSON.
 85 | 
 86 | ...Well, in fact not always. If there are two equal `admin/data.json` files (e.g. `data/a/admin/data.json` and `data/b/admin/data.json`), there may be two equal IDs. But admin won't do this, and we'll talk about user limitations later.
 87 | 
 88 | 
 89 | ## `val_col`
 90 | 
 91 | But object with one property doesn't look good. It would be nice if we could change `data.json` to:
 92 | 
 93 |     {
 94 |         "posts": {
 95 |             "1": "Post 1",
 96 |             "2": "Post 2"
 97 |         }
 98 |     }
 99 | 
100 | 
101 | And we can! That's the magic of `val_col`. First of all, let's change our `data/admin/data.json`. Then, let's change `dbschema.json`:
102 | 
103 |     "maps": {
104 |         "admin/data.json": {
105 |             "to_table": [
106 |                 {
107 |                     "node": "posts",
108 |                     "table": "posts",
109 |                     "key_col": "id",
110 |                     "val_col": "content"
111 |                 }
112 |             ]
113 |         }
114 |     }
115 | 
116 | We added `val_col` property. We told ZeroNet that property value is `content` column. Let's sign `content.json` and see what changed. You can add other posts to check that everything works.
117 | 
118 | 
119 | That's why I told that practically any JSON structure is OK. Simple `to_table` and advanced `key_col` and `val_col` can do much.
120 | 
121 | 
122 | ## `version`
123 | 
124 | Let's check our `json` table. Currently it has 3 columns: `json_id`, `directory` and `file_name`. That's because of `version: 2`. Let's speak about this `version` property:
125 | 
126 | - `version: 1`
127 |     1. `json_id` - ID of JSON file
128 |     2. `path` - Path to JSON file
129 |     
130 |     **What problems to expect**: None
131 | 
132 | - `version: 2`
133 |     1. `json_id` - ID of JSON file
134 |     2. `directory` - Directory of JSON file
135 |     3. `file_name` - Name of JSON file
136 | 
137 |     **What problems to expect**:
138 |     `directory` is relative to database file, so if file path is `data/admin/data.json`, and database path is `data/mydatabase.db`, then `directory` is `admin`. So, you cannot have a file in the same directory as database.
139 | 
140 | - `version: 3`
141 |     1. `json_id` - ID of JSON file
142 |     2. `site` - Site of JSON file
143 |     3. `directory` - Directory of JSON file
144 |     4. `file_name` - Name of JSON file
145 |     
146 |     **What problems to expect**:
147 |     The same as `version: 2`, but `site` is the part before the first slash in `directory`, and `directory` is the path after the first slash. So, you cannot have a file in the same directory as database and in a subdirectory of database (but subsubdirectory is OK).
148 |     
149 |     You may ask: "Why `site`?". That's because of merger sites. We'll talk about them later.
150 | 


--------------------------------------------------------------------------------
/9. user content.md:
--------------------------------------------------------------------------------
  1 | # User content
  2 | 
  3 | You have probably visited *ZeroMe* or *ZeroTalk* - a social network and a forum. They are created with *SQLite* - the database we talked about in the previous parts of this tutorial.
  4 | 
  5 | In previous parts, we created a zite with content created by administrator (like posts). Remember, we had no votes. Today we are going to fix this. We'll create a voting zite.
  6 | 
  7 | First of all, let's make a new zite.
  8 | 
  9 | 
 10 | ## Including `content.json`
 11 | 
 12 | We will have a directory `data/users`. It will have subdirectories (name is user's public key) with user files.
 13 | 
 14 | First of all, let's create a `content.json` for user data at `data/users/content.json` (ZeroNet will add other fields on signing):
 15 | 
 16 |     {
 17 |         "files": {}
 18 |     }
 19 | 
 20 | ...and include it somewhere to root `content.json`:
 21 | 
 22 |     ...,
 23 |     "ignore": "data/users/.*",
 24 |     "includes": {
 25 |         "data/users/content.json": {
 26 |             "signers": [],
 27 |             "signers_required": 1
 28 |         }
 29 |     },
 30 |     ...
 31 | 
 32 | The first line with `ignore` property tells ZeroNet that there should be not info about files in `data/users` directory. The other lines say that `data/users/content.json` should also be used when downloading zite.
 33 | 
 34 | Sign `content.json` and then `data/users/content.json`.
 35 | 
 36 | 
 37 | ## Creating correct `content.json`
 38 | 
 39 | We are going to use *ZeroID*. Just think: how can peers know that somebody can edit some folder? *ZeroID* and other *Certificate Authorities* prove that user can sign it.
 40 | 
 41 | Let's change `data/users/content.json`.
 42 | 
 43 |     {
 44 |         "ignore": ".*",
 45 |         "user_contents": {
 46 |             "cert_signers": {
 47 |                 "zeroid.bit": ["1iD5ZQJMNXu43w1qLB8sfdHVKppVMduGz"]
 48 |             },
 49 |             "permission_rules": {
 50 |                 ".*": {
 51 |                     "files_allowed": "data.json",
 52 |                     "max_size": 10000
 53 |                 }
 54 |             },
 55 |             "permissions": {
 56 |                 "ivanq@zeroid.bit": {
 57 |                     "max_size": 100000
 58 |                 }
 59 |             }
 60 |         }
 61 |     }
 62 | 
 63 | - `ignore` means that files inside are not signed by administrator.
 64 | - `user_contents.cert_signers` is a list of *Certificate Authorities*. Here we have `zeroid.bit` name and `1iD5ZQJMNXu43w1qLB8sfdHVKppVMduGz` zite has to prove that user can sign some directory.
 65 | - `user_contents.permission_rules` shows user permissions based on regular expressions. The key (`.*`) means "do the following for all users". The string which is matched against this regexp is `{authtype}/{username}@{zite}`. `authtype` is set by *Certificate Authority* (usually `web` or `bitmsg`). `files_allowed` is a regular expression for files which user can have. `max_size` is size (in bytes) of allowed files.
 66 | - `user_contents.permissions` lists user permissions for a single user. The key is `{username}@{zite}`. The value is the same as in `permission_rules`.
 67 | 
 68 | Here we allow 10 KB for everybody and 100 KB for `ivanq@zeroid.bit` (That's me!).
 69 | 
 70 | 
 71 | ## Creating `dbschema.json`
 72 | 
 73 | Let's create `dbschema.json` with these tables:
 74 | 
 75 |     +-------------------------------------------------------------------------+
 76 |     |                                questions                                |
 77 |     +-------------------------+-----------------------------------------------+
 78 |     | Row                     | Type                                          |
 79 |     +-------------------------+-----------------------------------------------+
 80 |     | id                      | INTEGER                                       |
 81 |     +-------------------------+-----------------------------------------------+
 82 |     | question                | TEXT                                          |
 83 |     +-------------------------+-----------------------------------------------+
 84 |     | answers                 | TEXT                                          |
 85 |     +-------------------------+-----------------------------------------------+
 86 |     | date_added              | INTEGER                                       |
 87 |     +-------------------------+-----------------------------------------------+
 88 |     | json_id                 | INTEGER REFERENCES json(json_id)              |
 89 |     +-------------------------------------------------------------------------+
 90 |     
 91 |     +-------------------------------------------------------------------------+
 92 |     |                                 answers                                 |
 93 |     +-------------------------+-----------------------------------------------+
 94 |     | Row                     | Type                                          |
 95 |     +-------------------------+-----------------------------------------------+
 96 |     | question_id             | INTEGER                                       |
 97 |     +-------------------------+-----------------------------------------------+
 98 |     | answer_id               | INTEGER                                       |
 99 |     +-------------------------+-----------------------------------------------+
100 |     | json_id                 | INTEGER REFERENCES json(json_id)              |
101 |     +-------------------------------------------------------------------------+
102 | 
103 | 
104 | `dbschema.json`:
105 | 
106 |     {
107 |         "db_name": "votes",
108 |         "db_file": "data/votes.db",
109 |         "version": 2,
110 |         "maps": {
111 |             "users/.*/data.json": {
112 |                 "to_table": [
113 |                     {
114 |                         "node": "questions",
115 |                         "table": "questions"
116 |                     },
117 |                     {
118 |                         "node": "answers",
119 |                         "table": "answers",
120 |                         "key_col": "question_id",
121 |                         "val_col": "answer_id"
122 |                     }
123 |                 ]
124 |             }
125 |         },
126 |         "tables": {
127 |             "json": {
128 |                 "cols": [
129 |                     ["json_id", "INTEGER PRIMARY KEY AUTOINCREMENT"],
130 |                     ["directory", "TEXT"],
131 |                     ["file_name", "TEXT"]
132 |                 ],
133 |                 "indexes": ["CREATE UNIQUE INDEX path ON json(directory, file_name)"],
134 |                 "schema_changed": 1
135 |             },
136 |             "questions": {
137 |                 "cols": [
138 |                     ["id", "integer"],
139 |                     ["question", "text"],
140 |                     ["answers", "text"],
141 |                     ["date_added", "integer"],
142 |                     ["json_id", "integer references json(json_id)"]
143 |                 ],
144 |                 "indexes": [
145 |                     "CREATE UNIQUE INDEX question_id ON questions(id)"
146 |                 ],
147 |                 "schema_changed": 1
148 |             },
149 |             "answers": {
150 |                 "cols": [
151 |                     ["question_id", "integer"],
152 |                     ["answer_id", "integer"],
153 |                     ["json_id", "integer references json(json_id)"]
154 |                 ],
155 |                 "indexes": [
156 |                     "CREATE UNIQUE INDEX answer_value ON answers(question_id, json_id)"
157 |                 ],
158 |                 "schema_changed": 1
159 |             }
160 |         }
161 |     }
162 | 
163 | The only new part is `users/.*/data.json`. It means: take all files from `data/users/{something}/data.json` and use it the following way: `...`.
164 | 
165 | 
166 | ## Authorizating via ZeroID
167 | 
168 | As I said before, we are going to use ZeroID. So, let's write code to do that.
169 | 
170 | First of all, create `js/index.js` and include it before other files:
171 | 
172 |     window.zeroFrame = new ZeroFrame();
173 | 
174 | Let's create a new file, `js/zeroid.js` and include it to `index.html`:
175 | 
176 |     function authAsZeroID(callback) {
177 |         zeroFrame.cmd("siteInfo", [], function(siteInfo) {
178 |             // If logged in, return object with username and public key (address)
179 |             if(siteInfo.cert_user_id) {
180 |                 callback({
181 |                     user: siteInfo.cert_user_id,
182 |                     address: siteInfo.auth_address
183 |                 });
184 |                 
185 |                 return;
186 |             }
187 |             
188 |             // Open authorization window and allow zeroid.bit
189 |             zeroFrame.cmd("certSelect", {
190 |                 accepted_domains: ["zeroid.bit"]
191 |             }, function() {
192 |                 zeroFrame.cmd("siteInfo", [], function(siteInfo) {
193 |                     // If logged in, return object with username and public key (address),
194 |                     // else return false
195 |                     if(siteInfo.cert_user_id) {
196 |                         callback({
197 |                             user: siteInfo.cert_user_id,
198 |                             address: siteInfo.auth_address
199 |                         });
200 |                     } else {
201 |                         callback(false);
202 |                     }
203 |                 });
204 |             });
205 |         });
206 |     }
207 | 
208 | 
209 | Now try to call `authAsZeroID(console.log.bind(console))` in console. A window will open. If you choose ZeroID, an object with `user` and `address` properties will appear in the console. If you choose `Unique to this site`, `false` will appear in the console.
210 | 
211 | We'll learn how to read and write user data in the following parts of the tutorial.
212 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | description: >-
 3 |   Welcome to ZeroNet, the P2P/distributed and anti-censorship free web hosting,
 4 |   that supports user signup/login using JS+MySQL without PHP. Make your
 5 |   site/app/service online 24/7 with 100% uptime.
 6 | ---
 7 | 
 8 | # Introduction
 9 | 
10 | 


--------------------------------------------------------------------------------
/SUMMARY.md:
--------------------------------------------------------------------------------
 1 | # Table of contents
 2 | 
 3 | * [Introduction](README.md)
 4 | * [1- Zites](1. zites.md)
 5 | * [2- Security](2. security.md)
 6 | * [3- Cloning zites](3. cloning zites.md)
 7 | * [4- Creating static zite](4. creating static zite.md)
 8 | * [5- ZeroFrame](5. zeroframe.md)
 9 | * [6- Databases](6. databases.md)
10 | * [7- Changing tables](7. changing tables.md)
11 | * [8- DbSchema](8. dbschema.md)
12 | * [9- User content](9. user content.md)
13 | * [10. Editing user data](10. editing user data.md)
14 | * [11- Merger sites](11. merger sites.md)
15 | * [12- Merged content](12. merged content.md)
16 | * [13- Ugly things.md](13. ugly things.md)
17 | * [Extra: 1- ZeroPage.md](1. zeropage.md)
18 | 
19 | 


--------------------------------------------------------------------------------
/downloads/ZeroAuth.js:
--------------------------------------------------------------------------------
 1 | class ZeroAuth {
 2 | 	constructor(page, acceptedDomains) {
 3 | 		if(typeof page != "object" || !page instanceof ZeroPage) {
 4 | 			throw new Error("page should be an instance of ZeroPage");
 5 | 		}
 6 | 		this.page = page;
 7 | 
 8 | 		if(acceptedDomains) {
 9 | 			if(typeof acceptedDomains != "object" || !acceptedDomains instanceof Array) {
10 | 				throw new Error("acceptedDomains should be an instance of Array");
11 | 			}
12 | 			this.acceptedDomains = acceptedDomains;
13 | 		} else {
14 | 			this.acceptedDomains = ["zeroid.bit"];
15 | 		}
16 | 
17 | 		this.activeAuth = null;
18 | 		this.page.cmd("siteInfo").then(siteInfo => {
19 | 			if(siteInfo.cert_user_id) {
20 | 				this.activeAuth = {
21 | 					user: siteInfo.cert_user_id,
22 | 					address: siteInfo.auth_address
23 | 				};
24 | 			}
25 | 		});
26 | 	}
27 | 
28 | 	getAuth() {
29 | 		return this.activeAuth;
30 | 	}
31 | 
32 | 	requestAuth() {
33 | 		if(this.activeAuth !== null && this.activeAuth !== undefined) {
34 | 			return Promise.resolve(this.activeAuth);
35 | 		} else {
36 | 			return new Promise((resolve, reject) => {
37 | 				this.page.once("setSiteInfo", () => {
38 | 					ZeroPage.async.setTimeout(200)
39 | 						.then(() => {
40 | 							return this.page.getSiteInfo();
41 | 						}).then(siteInfo => {
42 | 							if(siteInfo.cert_user_id !== null && siteInfo.cert_user_id !== undefined) {
43 | 								this.activeAuth = {
44 | 									user: siteInfo.cert_user_id,
45 | 									address: siteInfo.auth_address
46 | 								};
47 | 
48 | 								resolve(this.activeAuth);
49 | 							} else {
50 | 								this.activeAuth = null;
51 | 
52 | 								reject("User rejected to authorizate");
53 | 							}
54 | 						});
55 | 				});
56 | 
57 | 				this.page.cmd("certSelect", {
58 | 					accepted_domains: this.acceptedDomains
59 | 				});
60 | 			});
61 | 		}
62 | 	}
63 | 
64 | 	isValidAddress(address) {
65 | 		return address.indexOf("@") != -1 && // has @
66 | 		       address.indexOf("@", address.indexOf("@") + 1) == -1; // only one @
67 | 	}
68 | 	addressToFilename(address) {
69 | 		if(!this.isValidAddress(address)) return "";
70 | 
71 | 		return address.replace(/^(.*)@(.*)/, "[$1]$2");
72 | 	}
73 | };


--------------------------------------------------------------------------------
/downloads/ZeroFS.js:
--------------------------------------------------------------------------------
  1 | class ZeroFS {
  2 | 	constructor(page) {
  3 | 		if(typeof page != "object" || !page instanceof ZeroPage) {
  4 | 			throw new Error("page should be an instance of ZeroPage");
  5 | 		}
  6 | 		this.page = page;
  7 | 	}
  8 | 
  9 | 	fileExists(file) {
 10 | 		if(file == "") { // root
 11 | 			return Promise.resolve(true); // the following check will fail for root
 12 | 		}
 13 | 
 14 | 		let dirPath = file.split("/").slice(0, -1).join("/");
 15 | 		let basePath = file.split("/").pop();
 16 | 
 17 | 		return this.readDirectory(dirPath)
 18 | 			.then(children => {
 19 | 				return Promise.resolve(children.indexOf(basePath) > -1);
 20 | 			});
 21 | 	}
 22 | 	readFile(file) {
 23 | 		return this.page.cmd("fileGet", [
 24 | 			file, // file
 25 | 			false, // required (wait until file exists)
 26 | 			"text", // text or base64
 27 | 			300 // timeout
 28 | 		]).then(res => {
 29 | 			if(res === null || res === false) {
 30 | 				return Promise.reject("File doesn't exist: " + file);
 31 | 			} else {
 32 | 				return Promise.resolve(res);
 33 | 			}
 34 | 		});
 35 | 	}
 36 | 	writeFile(file, content, bytes) {
 37 | 		return this.page.cmd("fileWrite", [
 38 | 			file, // file
 39 | 			this.toBase64(content, bytes), // base64-encoded content
 40 | 			true // ignore bad files
 41 | 		]).then(res => {
 42 | 			if(res === "ok") {
 43 | 				return Promise.resolve(file);
 44 | 			} else {
 45 | 				return Promise.reject(res);
 46 | 			}
 47 | 		});
 48 | 	}
 49 | 	deleteFile(file) {
 50 | 		return this.page.cmd("fileDelete", [
 51 | 			file // file
 52 | 		]).then(res => {
 53 | 			if(res === "ok") {
 54 | 				return Promise.resolve(file);
 55 | 			} else {
 56 | 				return Promise.reject(res);
 57 | 			}
 58 | 		});
 59 | 	}
 60 | 
 61 | 	readDirectory(dir, recursive) {
 62 | 		return this.page.cmd("fileList", [
 63 | 			dir, // directory
 64 | 		]).then(res => {
 65 | 			if(recursive) {
 66 | 				return res.sort(); // If recursive, return as given
 67 | 			} else {
 68 | 				return res.map(file => { // Otherwise, crop by "/" symbol
 69 | 					if(file.indexOf("/") == -1) {
 70 | 						return file;
 71 | 					} else {
 72 | 						return file.substr(0, file.indexOf("/"));
 73 | 					}
 74 | 				}).reduce((arr, cur) => { // And make them unique
 75 | 					return arr.indexOf(cur) > -1 ? arr : arr.concat(cur);
 76 | 				}, []).sort();
 77 | 			}
 78 | 		});
 79 | 	}
 80 | 
 81 | 	getType(file) {
 82 | 		if(file == "") {
 83 | 			return Promise.resolve("dir");
 84 | 		}
 85 | 
 86 | 		let dir = file.split("/");
 87 | 		let relative = dir.pop();
 88 | 		dir = dir.join("/");
 89 | 
 90 | 		return this.page.cmd("fileList", [
 91 | 			dir, // directory
 92 | 		]).then(res => {
 93 | 			res = res.map(file => { // Crop by "/" symbol
 94 | 				if(file.indexOf("/") == -1) {
 95 | 					return file;
 96 | 				} else {
 97 | 					return file.substr(0, file.indexOf("/")) + "/";
 98 | 				}
 99 | 			});
100 | 
101 | 			if(res.indexOf(relative) > -1) {
102 | 				return "file";
103 | 			} else if(res.indexOf(relative + "/") > -1) {
104 | 				return "dir";
105 | 			} else {
106 | 				return Promise.reject("File doesn't exist: " + file);
107 | 			}
108 | 		});
109 | 	}
110 | 
111 | 	toBase64(str, bytes) {
112 | 		return btoa(bytes ? str : unescape(encodeURIComponent(str)));
113 | 	}
114 | 	fromBase64(str, bytes) {
115 | 		return bytes ? atob(str) : decodeURIComponent(escape(atob(str)));
116 | 	}
117 | }


--------------------------------------------------------------------------------
/downloads/ZeroPage.js:
--------------------------------------------------------------------------------
  1 | class ZeroPage {
  2 | 	constructor(frame) {
  3 | 		if(typeof frame != "object" || !frame instanceof ZeroFrame) {
  4 | 			throw new Error("frame should be an instance of ZeroFrame");
  5 | 		}
  6 | 		this.frame = frame;
  7 | 		this.progressId = 0;
  8 | 
  9 | 		this.savedPrivateKey = "";
 10 | 
 11 | 		this.initEventListeners();
 12 | 	}
 13 | 
 14 | 	/********************************* Logging ********************************/
 15 | 	logWith(type, args) {
 16 | 		let msg = args.map(v => this.objectToString(v)).join("\n");
 17 | 
 18 | 		this.cmd("wrapperNotification", [type, msg]);
 19 | 	}
 20 | 	log() {
 21 | 		console.info.apply(console, Array.prototype.slice.call(arguments));
 22 | 		this.logWith("info", Array.prototype.slice.call(arguments));
 23 | 	}
 24 | 	warn() {
 25 | 		console.warn.apply(console, Array.prototype.slice.call(arguments));
 26 | 		this.logWith("error", Array.prototype.slice.call(arguments));
 27 | 	}
 28 | 	error() {
 29 | 		console.error.apply(console, Array.prototype.slice.call(arguments));
 30 | 		this.logWith("error", Array.prototype.slice.call(arguments));
 31 | 	}
 32 | 	progress() {
 33 | 		let id = "progress" + (this.progressId++);
 34 | 		let msg;
 35 | 		let percent = 0;
 36 | 		let done = false;
 37 | 
 38 | 		let obj = {
 39 | 			setPercent: p => {
 40 | 				if(done) return;
 41 | 
 42 | 				percent = p;
 43 | 
 44 | 				if(percent == 0) {
 45 | 					this.cmd("wrapperProgress", [
 46 | 						id, // ID
 47 | 						msg, // message
 48 | 						0.05 // percent
 49 | 					]);
 50 | 					this.cmd("wrapperProgress", [
 51 | 						id, // ID
 52 | 						msg, // message
 53 | 						0 // percent
 54 | 					]);
 55 | 				} else {
 56 | 					this.cmd("wrapperProgress", [
 57 | 						id, // ID
 58 | 						msg, // message
 59 | 						percent // percent
 60 | 					]);
 61 | 				}
 62 | 			},
 63 | 			setMessage: (...args) => {
 64 | 				if(done) return;
 65 | 
 66 | 				msg = args.map(v => this.objectToString(v)).join("\n");
 67 | 
 68 | 				this.cmd("wrapperProgress", [
 69 | 					id, // ID
 70 | 					msg, // message
 71 | 					percent // percent
 72 | 				]);
 73 | 			},
 74 | 			done: () => {
 75 | 				if(done) return;
 76 | 				
 77 | 				obj.setPercent(100);
 78 | 				done = true;
 79 | 			},
 80 | 			error: () => {
 81 | 				if(done) return;
 82 | 
 83 | 				obj.setPercent(-1);
 84 | 				done = true;
 85 | 			}
 86 | 		};
 87 | 
 88 | 		obj.setMessage.apply(this, Array.prototype.slice.call(arguments));
 89 | 		
 90 | 		return obj;
 91 | 	}
 92 | 	prompt(msg, type) {
 93 | 		msg = this.objectToString(msg);
 94 | 		return this.cmd("wrapperPrompt", [msg, type || "text"]);
 95 | 	}
 96 | 	alert(msg) {
 97 | 		msg = this.objectToString(msg);
 98 | 		this.cmd("wrapperConfirm", [msg, "OK"]);
 99 | 	}
100 | 	confirm(msg, ok) {
101 | 		return this.cmd("wrapperConfirm", [msg, ok || "OK"]);
102 | 	}
103 | 
104 | 	/******************************** Commands ********************************/
105 | 	cmd(cmd, params) {
106 | 		return new Promise((resolve, reject) => {
107 | 			this.frame.cmd(cmd, params || [], res => {
108 | 				if(arguments.length) {
109 | 					resolve(res);
110 | 				} else {
111 | 					resolve();
112 | 				}
113 | 			});
114 | 		});
115 | 	}
116 | 
117 | 	/****************************** EventEmmiter ******************************/
118 | 	initEventListeners() {
119 | 		this.eventListeners = {
120 | 			on: {},
121 | 			once: {}
122 | 		};
123 | 
124 | 		this.frame.onRequest = (cmd, msg) => {
125 | 			this.emit(cmd, msg);
126 | 		};
127 | 	}
128 | 	on(cmd, callback) {
129 | 		if(!this.eventListeners.on.hasOwnProperty(cmd)) {
130 | 			this.eventListeners.on[cmd] = [];
131 | 		}
132 | 
133 | 		this.eventListeners.on[cmd].push(callback);
134 | 	}
135 | 	off(cmd, callback) {
136 | 		if(this.eventListeners.on.hasOwnProperty(cmd)) {
137 | 			if(this.eventListeners.on[cmd].indexOf(callback) != -1) {
138 | 				this.eventListeners.on[cmd].splice(this.eventListeners.on[cmd].indexOf(callback), 1);
139 | 			}
140 | 		}
141 | 		if(this.eventListeners.once.hasOwnProperty(cmd)) {
142 | 			if(this.eventListeners.once[cmd].indexOf(callback) != -1) {
143 | 				this.eventListeners.once[cmd].splice(this.eventListeners.once[cmd].indexOf(callback), 1);
144 | 			}
145 | 		}
146 | 	}
147 | 	once(cmd, callback) {
148 | 		if(!this.eventListeners.once.hasOwnProperty(cmd)) {
149 | 			this.eventListeners.once[cmd] = [];
150 | 		}
151 | 
152 | 		if(arguments.length <= 1) {
153 | 			return new Promise((resolve, reject) => {
154 | 				this.eventListeners.once[cmd].push((...args) => {
155 | 					resolve(...args);
156 | 				});
157 | 			});
158 | 		} else {
159 | 			this.eventListeners.once[cmd].push(callback);
160 | 		}
161 | 	}
162 | 	emit(cmd, arg) {
163 | 		if(this.eventListeners.on.hasOwnProperty(cmd)) {
164 | 			this.eventListeners.on[cmd].forEach(v => {
165 | 				if(arguments.length >= 2) {
166 | 					v(arg);
167 | 				} else {
168 | 					v();
169 | 				}
170 | 			});
171 | 		}
172 | 		if(this.eventListeners.once.hasOwnProperty(cmd)) {
173 | 			this.eventListeners.once[cmd].forEach(v => {
174 | 				if(arguments.length >= 2) {
175 | 					v(arg);
176 | 				} else {
177 | 					v();
178 | 				}
179 | 			});
180 | 			this.eventListeners.once[cmd] = [];
181 | 		}
182 | 	}
183 | 
184 | 	/****************************** Site control ******************************/
185 | 	getPrivateKey() {
186 | 		if(this.savedPrivateKey) {
187 | 			return Promise.resolve(this.savedPrivateKey);
188 | 		}
189 | 
190 | 		return this.getSiteInfo()
191 | 			.then(siteInfo => {
192 | 				if(siteInfo.privatekey) {
193 | 					return "stored";
194 | 				}
195 | 
196 | 				return this.prompt("Enter your private key:");
197 | 			}).then(privatekey => {
198 | 				this.savedPrivateKey = privatekey;
199 | 				return privatekey;
200 | 			});
201 | 	}
202 | 	sign(file) {
203 | 		file = file || "content.json";
204 | 
205 | 		return this.getPrivateKey()
206 | 			.then(privatekey => {
207 | 				return this.cmd(
208 | 					"siteSign",
209 | 					[
210 | 						privatekey, // private key
211 | 						file // file to sign
212 | 					]
213 | 				);
214 | 			}).then(res => {
215 | 				if(res === "ok") {
216 | 					return Promise.resolve(file);
217 | 				} else {
218 | 					return Promise.reject(res);
219 | 				}
220 | 			});
221 | 	}
222 | 	publish(file) {
223 | 		file = file || "content.json";
224 | 
225 | 		return this.getPrivateKey()
226 | 			.then(privatekey => {
227 | 				return this.cmd(
228 | 					"sitePublish",
229 | 					[
230 | 						privatekey, // private key
231 | 						file, // file to sign
232 | 						true // sign before publish
233 | 					]
234 | 				);
235 | 			}).then(res => {
236 | 				if(res === "ok") {
237 | 					return Promise.resolve(file);
238 | 				} else {
239 | 					return Promise.reject(res);
240 | 				}
241 | 			});
242 | 	}
243 | 	getSiteInfo() {
244 | 		return this.cmd("siteInfo");
245 | 	}
246 | 	getUser() {
247 | 		return this.getSiteInfo()
248 | 			.then(res => res.auth_address);
249 | 	}
250 | 	isSignable(file) {
251 | 		return this.getSiteInfo()
252 | 			.then(siteInfo => {
253 | 				if(siteInfo.privatekey) {
254 | 					return true;
255 | 				}
256 | 
257 | 				return this.cmd("fileRules", [file])
258 | 					.then(fileRules => fileRules && fileRules.signers && fileRules.signers.indexOf(siteInfo.auth_address) > -1);
259 | 			});
260 | 	}
261 | 
262 | 	/************************** Additional functions **************************/
263 | 	objectToString(v) {
264 | 		if(typeof v == "string") {
265 | 			return v;
266 | 		} else if(typeof v == "number") {
267 | 			return v.toString();
268 | 		} else if(typeof v == "undefined") {
269 | 			return "undefined";
270 | 		} else if(typeof v == "object") {
271 | 			if(v === null) {
272 | 				return "null";
273 | 			} else {
274 | 				let res;
275 | 				try {
276 | 					res = JSON.stringify(v, null, 4);
277 | 				} catch(e) {
278 | 					res = res.toString();
279 | 				}
280 | 				return res;
281 | 			}
282 | 		} else if(typeof v == "boolean") {
283 | 			return v ? "true" : "false";
284 | 		} else if(typeof v == "function") {
285 | 			return v.toString();
286 | 		} else {
287 | 			return "unknown";
288 | 		}
289 | 	}
290 | 	isFunctionCalledInside(search) { // Returns true if <search> function called function (that called isFunctionCalledInside)
291 | 		let caller = arguments.callee.caller;
292 | 		while(caller) {
293 | 			if(caller == selfFunc) {
294 | 				return true;
295 | 			}
296 | 			caller = caller.caller;
297 | 		}
298 | 		return false;
299 | 	}
300 | };
301 | ZeroPage.async = {
302 | 	setTimeout: time => {
303 | 		return new Promise((resolve, reject) => {
304 | 			setTimeout(() => {
305 | 				resolve();
306 | 			}, time);
307 | 		});
308 | 	},
309 | 	filter: (arr, f) => {
310 | 		return Promise.all(
311 | 				arr.map((elem, i) => {
312 | 					let v = f(elem, i, arr);
313 | 					if(v instanceof Promise) {
314 | 						return v;
315 | 					} else {
316 | 						return Promise.resolve(v);
317 | 					}
318 | 				})
319 | 			).then(result => { // Use the result of promises to call sync filter()
320 | 				return arr.filter((element, index) => {
321 | 					return result[index];
322 | 				});
323 | 			});
324 | 	},
325 | 	map: (arr, f) => {
326 | 		return Promise.all(
327 | 				arr.map((elem, i) => {
328 | 					let v = f(elem, i, arr);
329 | 					if(v instanceof Promise) {
330 | 						return v;
331 | 					} else {
332 | 						return Promise.resolve(v);
333 | 					}
334 | 				})
335 | 			).then(result => { // Use the result of promises to call sync filter()
336 | 				return arr.map((element, index) => {
337 | 					return result[index];
338 | 				});
339 | 			});
340 | 	},
341 | 	forEach: (arr, f) => {
342 | 		return Promise.all(
343 | 				arr.map((elem, i) => {
344 | 					let v = f(elem, i, arr);
345 | 					if(v instanceof Promise) {
346 | 						return v;
347 | 					} else {
348 | 						return Promise.resolve(v);
349 | 					}
350 | 				})
351 | 			);
352 | 	},
353 | 	concat: (...input) => {
354 | 		return Promise.all(input)
355 | 			.then(output => {
356 | 				return output.reduce((arr, prev) => prev.concat(arr), []);
357 | 			});
358 | 	}
359 | };


--------------------------------------------------------------------------------
/downloads/blog.html:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/purplesyringa/The-Truth-about-ZeroNet/2dbce9e1ce09bc8a5b80e034641eebba7d89c5fa/downloads/blog.html


--------------------------------------------------------------------------------
/downloads/blog_library.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/purplesyringa/The-Truth-about-ZeroNet/2dbce9e1ce09bc8a5b80e034641eebba7d89c5fa/downloads/blog_library.zip


--------------------------------------------------------------------------------
/downloads/blog_modern.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/purplesyringa/The-Truth-about-ZeroNet/2dbce9e1ce09bc8a5b80e034641eebba7d89c5fa/downloads/blog_modern.zip


--------------------------------------------------------------------------------
/downloads/blog_single.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/purplesyringa/The-Truth-about-ZeroNet/2dbce9e1ce09bc8a5b80e034641eebba7d89c5fa/downloads/blog_single.zip


--------------------------------------------------------------------------------
/downloads/notepad.html:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/purplesyringa/The-Truth-about-ZeroNet/2dbce9e1ce09bc8a5b80e034641eebba7d89c5fa/downloads/notepad.html


--------------------------------------------------------------------------------
/downloads/notepad_single.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/purplesyringa/The-Truth-about-ZeroNet/2dbce9e1ce09bc8a5b80e034641eebba7d89c5fa/downloads/notepad_single.zip


--------------------------------------------------------------------------------
/downloads/notepad_zerofs.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/purplesyringa/The-Truth-about-ZeroNet/2dbce9e1ce09bc8a5b80e034641eebba7d89c5fa/downloads/notepad_zerofs.zip


--------------------------------------------------------------------------------
/downloads/notepad_zeropage.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/purplesyringa/The-Truth-about-ZeroNet/2dbce9e1ce09bc8a5b80e034641eebba7d89c5fa/downloads/notepad_zeropage.zip


--------------------------------------------------------------------------------
/downloads/portfolio.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/purplesyringa/The-Truth-about-ZeroNet/2dbce9e1ce09bc8a5b80e034641eebba7d89c5fa/downloads/portfolio.zip


--------------------------------------------------------------------------------
/downloads/voting.html:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/purplesyringa/The-Truth-about-ZeroNet/2dbce9e1ce09bc8a5b80e034641eebba7d89c5fa/downloads/voting.html


--------------------------------------------------------------------------------
/downloads/voting_library.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/purplesyringa/The-Truth-about-ZeroNet/2dbce9e1ce09bc8a5b80e034641eebba7d89c5fa/downloads/voting_library.zip


--------------------------------------------------------------------------------
/downloads/voting_modern.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/purplesyringa/The-Truth-about-ZeroNet/2dbce9e1ce09bc8a5b80e034641eebba7d89c5fa/downloads/voting_modern.zip


--------------------------------------------------------------------------------
/downloads/voting_single.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/purplesyringa/The-Truth-about-ZeroNet/2dbce9e1ce09bc8a5b80e034641eebba7d89c5fa/downloads/voting_single.zip


--------------------------------------------------------------------------------
/extra/1. zeropage.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/purplesyringa/The-Truth-about-ZeroNet/2dbce9e1ce09bc8a5b80e034641eebba7d89c5fa/extra/1. zeropage.md


--------------------------------------------------------------------------------
/extra/2. zeronet vs. others.md:
--------------------------------------------------------------------------------
1 | # ZeroNet vs. others
2 | 
3 | ## vs. IPFS
4 | 
5 | ## vs. Dat
6 | 
7 | ## vs. Freenet
8 | 


--------------------------------------------------------------------------------