Slovak: Remove english parts from Lesson6

sk/6/01.md

@@ -364,26 +364,18 @@ material:
 ---
 
 Dokončením Lekcie 5 je naša DApp hotová. Teraz ideme vytvoriť jednoduchú stránku, pomocou ktorej môžu užívateľia interagovať s našou DApp. 
-By completing Lesson 5, our zombie DApp is now complete. Now we're going to create a basic web page where your users can interact with it.
 
 Na to budeme potrebovať Javascriptovú knižnicu od Ethereum Foundation nazývanú **_Web3.js_**.
-To do this, we're going to use a JavaScript library from the Ethereum Foundation called **_Web3.js_**.
 
 ## Čo je to Web3.js?
-## What is Web3.js?
 
 Drž na pamäti, že Ethereum sieť je tvorená uzlami, a každý z nich si udržuje kópiu celej blockchain. Keď chceš zavolať funkciu a smart kontrakte, je nutné poslať dotaz jednému zo serverov a povedať mu:
-Remember, the Ethereum network is made up of nodes, which each contain a copy of the blockchain. When you want to call a function on a smart contract, you need to query one of these nodes and tell it:
 
  1. Adresu tvojho smart kontraktu
  2. Funkciu ktorú chceš volať
  3. Premenné ktoré chceš funkcií poslať
- 1. The address of the smart contract
- 2. The function you want to call, and
- 3. The variables you want to pass to that function.
 
 Etereum uzly "rozprávajú" len jazykom zvaným **_JSON-RPC_**, ktorý pre ľudí nie je ľahko čitateľný. Dotaz na Ethereum uzol, aby zavolal určitú funkciu kontraktu by vyzeral zhruba takto: 
-Ethereum nodes only speak a language called **_JSON-RPC_**, which isn't very human-readable. A query to tell the node you want to call a function on a contract looks something like this:
 
 ```
 // hmmm... veľa šťastia s písaním takýchto funkčných volaní po celý deň
@@ -392,24 +384,19 @@ Ethereum nodes only speak a language called **_JSON-RPC_**, which isn't very hum
 ```
 
 Naštastie Web3.js nás štíti od takýchto škaredo vyzerajúcich dotazov pod povrchom. Ty budeš vidieť a pracovať s, pekným a čitateľným Javascriptovým rozhraním.
-Luckily, Web3.js hides these nasty queries below the surface, so you only need to interact with a convenient and easily readable JavaScript interface.
 
 Namiesto toho aby sme konštruovali dotazy ako sme videli vyššie, volanie funkcie v tvojom kóde bude vyzerať nejako takto:
-Instead of needing to construct the above query, calling a function in your code will look something like this:
 
 ```
 CryptoZombies.methods.createRandomZombie("Vitalik Nakamoto 🤔")
   .send({ from: "0xb60e8dd61c5d32be8058bb8eb970870f07233155", gas: "3000000" })
 ```
 
 Syntax si podrobne vysvetlíme v priebehu ďalších kapitol. Ale ešte pred tým poďme nastaviť Web3.js v tvojom projekte.
-We'll explain the syntax in detail over the next few chapters, but first let's get your project set up with Web3.js.
 
 ## Začíname
-## Getting started
 
 V závislosti od toho aké nástroje používaš, možeš pridať Web3.js do svojho projektu jedným z nasledujúcich spôsobov:
-Depending on your project's workflow, you can add Web3.js to your project using most package tools:
 
 ```
 // Using NPM
@@ -424,21 +411,16 @@ bower install web3
 // ...etc.
 ```
 
-Alebo si môžeš proste stiahnut minifikovaný `.js` súbor z <a href="https://github.com/ethereum/web3.js/blob/1.0/dist/web3.min.js" target=_blank>githubu</a> a začleniť ho do svojho projketu:
-Or you can simply download the minified `.js` file from <a href="https://github.com/ethereum/web3.js/blob/1.0/dist/web3.min.js" target=_blank>github</a> and include it in your project:
+Alebo si môžeš proste stiahnut minifikovaný `.js` súbor z <a href="https://github.com/ethereum/web3.js/blob/1.0/dist/web3.min.js" target=_blank>githubu</a> a začleniť ho do svojho projektu:
 
 ```
 <script language="javascript" type="text/javascript" src="web3.min.js"></script>
 ```
 
-Nakoľko nechcem robiť predpoklady o tom ako vyzerá tvoje vývojové prostredie, alebo aký package manager používaš, v tomto tutoriále budeme proste includeovať Web3 v tvojom projekte použitím tagu, ako sme to videli na príklade.
-Since we don't want to make too many assumptions about your development environment and what package manager you use, for this tutorial we're going to simply include Web3 in our project using a script tag as above.
+Nakoľko nechcem robiť predpoklady o tom ako vyzerá tvoje vývojové prostredie, alebo aký package manager používaš, v tomto tutoriále budeme proste zahrnúť Web3 v tvojom projekte použitím tagu, ako sme to videli na príklade.
 
 ## Vyskúšaj si to sám
-## Put it to the Test
 
 Vytvorili sme základ tvojho HTML projektu za teba. Pozri sa na súbor `index.html`. Budeme predpokladať, že máš stiahnutú kópiu `web3.min.js` v rovankom adresári v akom je `index.html`.
-We've created a shell of an HTML project file for you, `index.html`. Let's assume we have a copy of `web3.min.js` in the same folder as `index.html`.
 
 1. Skopíruj si do projektu script tag z príkladu vyššie. aby sme v projekte mohli používať `web3.js`
-1. Go ahead and copy/paste the script tag above into our project so we can use `web3.js`

sk/6/02.md

@@ -384,65 +384,49 @@ material:
 ---
 
 Skvelé! Teraz, keď máme Web3.js v našom projekte, poďme ho inicializovať a začat komunikovať s blockchain.
-Great! Now that we have Web3.js in our project, let's get it initialized and talking to the blockchain.
 
 Prvá vec ktorú budeme potrebovať je **_Web3 Provider_**.
-The first thing we need is a **_Web3 Provider_**.
 
 Nezabudni že Ethereum sieť je vytvorená z **_uzlov_**. Všetky uzly zdieľajú kópiu identických dát. Tým, že nakonfigurujeme naš Web3 Provider vo Web3.js mu povieme s ktorým **Ethereum uzlom** má komunikovať pre čítanie a zapisovanie dát na blockchain. Je to podobné ako keď v kóde nastavíš URL serveru s ktorým má front end komunikovať v prípade tradičnej webovej aplikácie.
-Remember, Ethereum is made up of **_nodes_** that all share a copy of the same data. Setting a Web3 Provider in Web3.js tells our code **which node** we should be talking to handle our reads and writes. It's kind of like setting the URL of the remote web server for your API calls in a traditional web app.
 
 Ak chceš, môžeš si rozbiehať Ethereum uzol sám a použiť ako svojho providera. Život budeš mať ale jednoduchší ak použiješ niektorú z existujúcich služieb, ktorá sa o takéto Ethereum uzly stará. Takou službou je napríklad — **_Infura_**.
-You could host your own Ethereum node as a provider. However, there's a third-party service that makes your life easier so you don't need to maintain your own Ethereum node in order to provide a DApp for your users — **_Infura_**.
 
 ## Infura
 
 <a href="https://infura.io/" target=_blank>Infura</a> je služba ktorá sa stará o niekoľko Ethereum uzlov s cachovacou vrstvou pre rýchly prístup kdátam. Môžeš ju využívať prostredníctvom ich API. Tým že využiješ Infuru ako svojho providera budeš môcť spoľahlivo odosielať a príjmať správy do/z Ethereum blockchain bez toho aby si sa musel bežať svoj vlastný Ethereum uzol.
-<a href="https://infura.io/" target=_blank>Infura</a> is a service that maintains a set of Ethereum nodes with a caching layer for fast reads, which you can access for free through their API. Using Infura as a provider, you can reliably send and receive messages to/from the Ethereum blockchain without needing to set up and maintain your own node.
 
 Aby si začal používať Web3 ako svojho web3 providera, môžeš použiť toto: 
-You can set up Web3 to use Infura as your web3 provider as follows:
 
 ```
 var web3 = new Web3(new Web3.providers.WebsocketProvider("wss://mainnet.infura.io/ws"));
 ```
 
 Naša aplikácia bude však používaná mnohými užívateľmi - týto používatelia budú dáta na blockchain ZAPISOVAŤ, nie len čítať. Budeme preto potrebovať spôsobob, ako nechať užívateľov podpísať transakcie svojim privátnym kľúčom.
-However, since our DApp is going to be used by many users — and these users are going to WRITE to the blockchain and not just read from it — we'll need a way for these users to sign transactions with their private key.
 
 > Note: Ethereum (a iné obecne aj iné blockchainy) používajú pár verejného / súkromného kľúča na to aby digitálne podpísali transakcie. Môžeš si to predstaviť ako extrémne bezpečné heslo pre digitálny podpis. Tým pádom, ak zmením nejaké dáta v blockchain, môžem **dokázať** pomocou svojho verejného kľuča, že som to bol skutočne ja, kto túto transakciu podpísal. Keďže nikto iný nepozná môj privátny kľúč, niekto nemôže falošne vytvoriť transkaciu pod mojim menom. 
-> Note: Ethereum (and blockchains in general) use a public / private key pair to digitally sign transactions. Think of it like an extremely secure password for a digital signature. That way if I change some data on the blockchain, I can **prove** via my public key that I was the one who signed it — but since no one knows my private key, no one can forge a transaction for me.
 
 Kryptografia je komplikovaná, takže pokiaľ nie si bezpečnostným expertom, ktorý presne vie čo robí, bude asi lepšie ak sa nebudeš sám spravovať privátne kľúče užívateľov vo svojom front ende. 
-Cryptography is complicated, so unless you're a security expert and you really know what you're doing, it's probably not a good idea to try to manage users' private keys yourself in our app's front-end.
 
 Našťastie nemusíš - existujú služby ktoré sa o tieto záležitosti postarajú za teba. Jednou z najpopulárnejších možností je **_Metamask_**.
-But luckily you don't need to — there are already services that handle this for you. The most popular of these is **_Metamask_**.
 
 ## Metamask
 
 <a href="https://metamask.io/" target=_blank>Metamask</a> je plugin v prihliadači, dostupný pre Chrome aj Firefox, ktorý umožňuje užívateľom bezpečne spravovať ich Ethereum účty, privátne kľúče, a používať tieto účty na prácu so stránkami, ktoré používajú Web3.js. (Ak si Metamask doposiaľ nepoužíval, rozhodne ti ho odporúčam vyskúšať. Môžeš potom surfovať web s aktivovaným Web3, čo znamená, že budeš môcť interagovať s ľubovolnou webstránkou, ktorá komunikuje s Ethereum blockchain!).
-<a href="https://metamask.io/" target=_blank>Metamask</a> is a browser extension for Chrome and Firefox that lets users securely manage their Ethereum accounts and private keys, and use these accounts to interact with websites that are using Web3.js. (If you haven't used it before, you'll definitely want to go and install it — then your browser is Web3 enabled, and you can now interact with any website that communicates with the Ethereum blockchain!).
 
 Z pohľadu vývojara, pokiaľ chceš aby užívatelia mohli pracovať s tvojou Ethereum DAppkou prostredníctvo stránky vo webovom prehliadači (ako to robíme v prípade CryptoZombies hry), budeš ju definitívne musieť spraviť kompatibilnú s Metamaskom.
-And as a developer, if you want users to interact with your DApp through a website in their web browser (like we're doing with our CryptoZombies game), you'll definitely want to make it Metamask-compatible.
 
 > **Poznámka**: Metamask pod kapotou používa Infra servre ako svoj web3 provider, rovnako ako sme to vyššie spravili my. No taktiež dáva užívateľovi možnosť použiť vlastný web3 provider. Čiže používaním web3 providera Metamasku dávaš svojim užívateľom možnosť voľby. To máme hneď o jednu starosť menej.
-> **Note**: Metamask uses Infura's servers under the hood as a web3 provider, just like we did above — but it also gives the user the option to choose their own web3 provider. So by using Metamask's web3 provider, you're giving the user a choice, and it's one less thing you have to worry about in your app.
 
 ## Používanie Web3 providera Metamasku
 ## Using Metamask's web3 provider
 
 Metamask vkladá svoj Web3 provider v prhehliadači do globálneho JavaScriptového objektu `web3`. Tvoja aplikácia teda môže skontrolovať či objekt `web3` existuje, a na základe toho sa rozhodnúť či použije `web3.currentProvider` ako svoj provider.
-Metamask injects their web3 provider into the browser in the global JavaScript object `web3`. So your app can check to see if `web3` exists, and if it does use `web3.currentProvider` as its provider.
 
 Tu je ukážkový kód toho, ako môžeme detekovať či má užívateľ nainštalovaný Metamask. Ak nema, môžme užívateľovi ohlásiť že si ho bude musiet nainštalovať na to, aby mohol používať v našej aplikácií:
-Here's some template code provided by Metamask for how we can detect to see if the user has Metamask installed, and if not tell them they'll need to install it to use our app:
 
 ```
 window.addEventListener('load', function() {
 
-  // Checking if Web3 has been injected by the browser (Mist/MetaMask)
   // Skontrolujeme či bol Web3 vložený do našeho prehliadača (Mist/Metamask)
   if (typeof web3 !== 'undefined') {
     // Použi provider Mistu/MetaMasku
@@ -460,17 +444,12 @@ window.addEventListener('load', function() {
 ```
 
 Túto šablónu kódu môžme používať v aplikáciách, ktoré potrebujú aby mal užívateľ Metamask na prácu s DAppkou.
-You can use this boilerplate code in all the apps you create in order to require users to have Metamask to use your DApp.
 
 > Poznámka: Okrem Metamasku existujú aj iné programy pre spravovanie privátnych kľučov užívateľov, napríklad webový prehliadač **Mist**. Všetky však fungujú podobný spôsobom tak, že v prehliadači vytvoria globálnu premennú `web3`. Preto aj v nich bude spomínaná metóda pre detekovanie web3 providera užívateľa fungovať.
-> Note: There are other private key management programs your users might be using besides MetaMask, such as the web browser **Mist**. However, they all implement a common pattern of injecting the variable `web3`, so the method we describe here for detecting the user's web3 provider will work for these as well.
 
 ## Vyskúšaj si to sám
-## Put it to the Test
 
 Pre uzatváracím tagom `</body>` v tvojom HTML súbore sme vytvorili prázdny script tag. V tejto lekcii do neho budeme písať všetok náš javascriptový kód.
-We've created some empty script tags before the closing `</body>` tag in our HTML file. We can write our javascript code for this lesson here.
 
 1. V tejto kapitole začni tým, že skopíruješ vyššie ukázanú šablónu na detekciu Metamasku. Je to ten kód, ktorý začína riadkom `window.addEventListener`.
-1. Go ahead and copy/paste the template code from above for detecting Metamask. It's the block that starts with `window.addEventListener`.