ad sẽ hướng dẫn chạy trên window còn ai dùng vps thì có thể lên đây xem cách cài những cái cần thiết link - mục install

bước 1 : tải các phần mềm cần thiết

1 . tải hyper -V : link - tải xong về bấm chuột phải chọn run as administrator cho nó tự cài

2 tải docker window : link

3 tai Node.js - link

4 tải git - link

2 3 4 tải về cứ cài như bình thường

bước 2 mở phần mềm docker window ( phần mêm này phải luôn mở trong quá trình làm )

sau khi cài xong mà mở lên nó báo lỗi thì hãy vào cmd ( ctrl + r và nhập cmd để mở ) sau đó chạy lệnh wsl --update

sau khi chạy xong và mở docker window lên

bước 3 cài subsquid CLI

bật cmd và chạy lần lượt 2 lệnh bên dưới

npm install --global @subsquid/cli@latest

sqd --version

khi kiểm tra ra phiển bản nhìn giống trên ảnh là ok

bước 4 : chạy 4 nhiệm vụ deloy

mỗi nhiệm vụ sẽ có 1 key và 1 link tải đầu tiên khác nhau và khi tải về nó sẽ ra các thư mục khác nhau thì mọi người chú ý

ad sẽ hướng dẫn chạy single-chain-squid còn 3 cái sau nó tương tự y hệt chỉ khác mỗi cái link đầu vào

vào mục quest trên web subsquid - link

và tải cái key ở nhiệm vụ single chain squid về

bật cmd bạn nên xem mình muốn lưu file tý nữa tạo ở ổ nào nếu ở ổ C mặc định thì k cần làm j cả - nếu muốn chuyển sang ổ D hay E j đó thì trong cmd hãy gõ lệnh D: hoặc E:

sau dó nhập lệnh này chạy nó sẽ tạo ra 1 file ở trong ổ mà bạn đã để

sqd init xxxxxx -t https://github.com/subsquid-quests/single-chain-squid

thay đổi xxxx thành tên mình muốn đặt cho cái thư mục

sau khi lênh trên chạy xong hãy chạy tiếp 1 lệnh này

cd xxxxxx

( xxxx là tên mình vừa tạo ở trên )

ví dụ sẽ đặt tên là test1

sau khi xong sẽ có 1 file tên là test1 ở trong ổ mình đã đặt - sau đó hãy copy file key tải khi nay vào file test1 đó mục query-gateway và ném vào trong mục key như ảnh bên dưới

bước tiếp theo quay lại cmd và chạy lệnh sqd up ( lưu ý docker window phải bật và k cần sing in cũng đc )

sqd up

lần đầu chạy thì nó có thể lên đến 10 20 cái j đó nhé cứ để nó chạy xong

sau đó chạy tiếp lệnh npm ci

npm ci

tiếp tục chạy tiếp lệnh 2 lệnh bên dưới

sqd build

sqd migration:apply

sau đó chạy lệnh sqd run và cứ để cho nó chạy lúc nào thanh % trên nhiệm vụ trên web đầy và cho claim thì thôi

sqd run

trong khi nó chạy thì thỉnh thoảng check web xem % nó lên đc bn vào cho claim chưa

sau khi claim thì quay lại cmd và bấm ctrl + C và nhập sqd down

để dừng và xóa file chạy trên docker window

thế là đã xong 1 nhiệm vụ - bên dưới là các link tải của các nhiệm vụ tiếp theo

double

sqd init xxxxxx -t https://github.com/subsquid-quests/double-chain-squid

triple

sqd init xxxxxx -t https://github.com/subsquid-quests/triple-chain-squid

quad

sqd init xxxxxxx -t https://github.com/subsquid-quests/quad-chain-squid

xxxxx là tên mình tự đọc và tên k trùng nhau

khi chạy nó đều sẽ chạy ra 1 file riêng

các nhiệm vụ sau chỉ cần chạy lại từ bước 4 k phải làm từ các bước trước

https://community.starknet.io/t/greetings/16734/33

Bước 2 : tạo username và tên

Bước 3 : nhấp vào profile và chọn chat với bot

tiếp tục làm như những ảnh bên dưới

chọn 1 ngày tùy ý

trả lời bằng 1 link bất kỳ

trả lời bằng 1 icon

trả lời bằng chữ in đậm hoặc nghiêng

trả lời bằng quote - click đúp chuột vào chỗ văn bản

like và trả lời bằng hình ảnh

tìm kiếm từ khóa capy​bara

kết thúc - nhận lấy chứng chỉ sơ cấp - làm tiếp theo bên dưới để lấy chứng chỉ cao cấp

chứng chỉ cao cấp bấm reply bất kỳ cái nào rùi gọi bot

edit lại đoạn văn bản nó cho

xóa đoạn văn bản

lấy lại đoạn văn bản

trả lời bằng #

bật thông báo

trả lời bằng hiden details

kết thúc sẽ nhận chứng chỉ cao cấp

B1 : liên kết ví chọn chain tùy ý và bấm create NFT

B2 : sau khi tạo xong quay lại chỗ ban đầu và chọn my NFT và chọn NFT mới tạo vào

đợi nó chạy xong rùi claim

sau đó sang mục history copy id của bước 3

qua mục redeem dán vào

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Contract {
    bool public a = true;
    bool public b = false;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Contract {
    uint8 public a = 3;
    uint16 public b = 268;
    uint256 public sum = a + b;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Contract {
    int8 public a = 10;
    int8 public b = -15;
    int16 public difference = a - b;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Contract {
    bytes32 public msg1 = "Hello World";
    string public msg2 = "ccccccccccccccccccccccccccccccccabcd";
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Contract {
    enum Foods { Apple, Pizza, Bagel, Banana }

    Foods public food1 = Foods.Apple;
    Foods public food2 = Foods.Pizza;
    Foods public food3 = Foods.Bagel;
    Foods public food4 = Foods.Banana;
}

Functions

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Contract {
    uint public x;

    constructor(uint _x) {
        x = _x;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Contract {
    uint public x;

    constructor(uint _x) {
        x = _x;
    }

    function increment() external {
        x = x + 1;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Contract {
    uint public x;

    constructor(uint _x) {
        x = _x;
    }

    function increment() external {
        x = x + 1;
    }

    function add(uint _x) external view returns(uint) {
        uint sum = x + _x;
        return sum;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Contract {
    function double(uint x) external pure returns(uint d) {
        d = x * 2;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Contract {
    function double(uint x) external pure returns(uint d) {
        d = x * 2;
    }

    function double(uint x, uint y) public pure returns(uint, uint) {         
            return (x*2, y*2);
    }
}

Smart Contract Communication

/**
 * Find the `value` stored in the contract
 *
 * @param {ethers.Contract} contract - ethers.js contract instance
 * @return {promise} a promise which resolves with the `value`
 */
function getValue(contract) {
    let value = contract.value();
    return value;
}

module.exports = getValue;

/**
 * Modify the `value` stored in the contract
 *
 * @param {ethers.Contract} contract - ethers.js contract instance
 * @return {promise} a promise of transaction
 */
function setValue(contract) {
    return contract.modify(6);
}

module.exports = setValue;

/**
 * Transfer funds on the contract from the current signer 
 * to the friends address
 *
 * @param {ethers.Contract} contract - ethers.js contract instance
 * @param {string} friend - a string containing a hexadecimal ethereum address
 * @return {promise} a promise of the transfer transaction
 */
function transfer(contract, friend) {
    return contract.transfer(friend, 1000);
}

module.exports = transfer;

/**
 * Set the message on the contract using the signer passed in
 *
 * @param {ethers.Contract} contract - ethers.js contract instance
 * @param {ethers.types.Signer} signer - ethers.js signer instance
 * @return {promise} a promise of transaction modifying the `message`
 */
function setMessage(contract, signer) {
    return contract.connect(signer).modify("abc");
}

module.exports = setMessage;

const ethers = require('ethers');

/**
 * Deposit at least 1 ether into the contract 
 *
 * @param {ethers.Contract} contract - ethers.js contract instance
 * @return {promise} a promise of the deposit transaction 
 */
function deposit(contract) {
    return contract.deposit({ value: ethers.utils.parseEther("3") });
}

module.exports = deposit;

Address Interactions

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Contract {
    address public owner;

    constructor() {
        owner = msg.sender;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Contract {
    address public owner;

    constructor() {
        owner = msg.sender;
    }

    receive() external payable {
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Contract {
    address public owner;

    constructor() {
        owner = msg.sender;
    }

    receive() external payable {
    }

    function tip() public payable {
        (bool ret, ) = owner.call{ value: msg.value }("");
        require(ret);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Contract {
    address public owner;
    address public charity;

    constructor(address _charity) {
        owner = msg.sender;
        charity = _charity;
    }

    receive() external payable {
    }

    function tip() public payable {
        (bool ret, ) = owner.call{ value: msg.value }("");
        require(ret);
    }

    function donate() public {
        (bool ret, ) = charity.call{ value: address(this).balance }("");
        require(ret);
        selfdestruct(payable(msg.sender));
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Contract {
    address public owner;
    address public charity;

    constructor(address _charity) {
        owner = msg.sender;
        charity = _charity;
    }

    receive() external payable {
    }

    function tip() public payable {
        (bool ret, ) = owner.call{ value: msg.value }("");
        require(ret);
    }

    function donate() public {
        (bool ret, ) = charity.call{ value: address(this).balance }("");
        require(ret);
        selfdestruct(payable(msg.sender));
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Contract  {
    address deployer;

    constructor() payable {
        require(msg.value >= 1000000000000000000);
        deployer = msg.sender;
    }

    function withdraw() public {
        (bool ret, ) = deployer.call{ value: address(this).balance }("");
        require(ret);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Contract  {
    address deployer;

    constructor() payable {
        require(msg.value >= 1000000000000000000);
        deployer = msg.sender;
    }

    function withdraw() public {
        require(deployer == msg.sender);
        (bool ret, ) = deployer.call{ value: address(this).balance }("");
        require(ret);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.5;

contract Contract {
    address owner;
    uint configA;
    uint configB;
    uint configC;

    constructor() {
        owner = msg.sender;
    }

    function setA(uint _configA) public onlyOwner {
        configA = _configA;
    }

    function setB(uint _configB) public onlyOwner {
        configB = _configB;
    }

    function setC(uint _configC) public onlyOwner {
        configC = _configC;
    }

    modifier onlyOwner {
        require(owner == msg.sender);
        _;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

interface IHero {
    function alert() external;
}

contract Sidekick {
    function sendAlert(address hero) external {
        IHero(hero).alert();
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Sidekick {
    function sendAlert(address hero) external {
        bytes4 signature = bytes4(keccak256("alert()"));

        (bool ret, ) = hero.call(abi.encodePacked(signature));

        require(ret);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Sidekick {
    function sendAlert(address hero, uint enemies, bool armed) external {
        (bool ret, ) = hero.call(
            abi.encodeWithSignature("alert(uint256,bool)", enemies, armed)
        );

        require(ret);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Sidekick {
    function relay(address hero, bytes memory data) external {
        (bool ret, ) = hero.call(data);
        require(ret);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Sidekick {
    function makeContact(address hero) external {
        (bool ret, ) = hero.call(abi.encodeWithSignature("fallback()"));
        require(ret);
    }
}

pragma solidity ^0.8.4;

contract Contract {
    function sumAndAverage(uint a, uint b, uint c, uint d) external pure returns(uint,uint) {
        uint sum = a + b + c + d;
        uint average = sum / 4;

        return (sum, average);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract Contract {
    uint countdown = 10;

    function tick() external {
        countdown--;
        if (0 == countdown) {
            selfdestruct(payable(msg.sender));
        }
    }
}

const provider = require('./provider');

async function getBlockNumber() {
    const ret = await provider.send({
        jsonrpc: "2.0",
        id: 1,
        method: "eth_blockNumber",
    });
    return ret.result;
}

module.exports = getBlockNumber;

const provider = require('./provider');

async function getBalance(address) {
    const ret = await provider.send({
        jsonrpc: "2.0",
        id: 1,
        method: "eth_getBalance",
        params: [address, "latest"],
    });
    return ret.result;
}

module.exports = getBalance;

const provider = require('./provider');

async function getNonce(address) {
    const ret = await provider.send({
        jsonrpc: "2.0",
        id: 1,
        method: "eth_getTransactionCount",
        params: [address, "latest"],
    });
    return ret.result;
}

module.exports = getNonce;

const provider = require('./provider');

async function getTotalTransactions(blockNumber) {
    const ret = await provider.send({
        jsonrpc: "2.0",
        id: 1,
        method: "eth_getBlockByNumber",
        params: [blockNumber, false],
    });
    return ret.result.transactions.length;
}

module.exports = getTotalTransactions;

const provider = require('./provider');

async function getTotalBalance(addresses) {
    let reqs = [];
    for (let i = 0; i < addresses.length; i++) {
        reqs.push({
            jsonrpc: "2.0",
            id: 1,
            method: "eth_getBalance",
            params: [addresses[i], "latest"],
        });
    }
    const resps = await provider.send(reqs);
    let t = 0;
    for (let i = 0; i < resps.length; i++) {
        t = t + parseInt(resps[i].result);
    }
    return t;
}

module.exports = getTotalBalance;

Front-End Libraries

const ethers = require('ethers');
const { Wallet } = ethers;

// create a wallet with a private key
const wallet1 = new Wallet("0xf2f48ee19680706196e2e339e5da3491186e0c4c5030670656b0e0164837257d");

// create a wallet from mnemonic
const wallet2 = Wallet.fromMnemonic("plate lawn minor crouch bubble evidence palace fringe bamboo laptop dutch ice");

module.exports = {
    wallet1,
    wallet2,
}

const ethers = require('ethers');
const { Wallet, utils } = ethers;
const { wallet1 } = require('./wallets');

const signaturePromise = wallet1.signTransaction({
    value: utils.parseEther('1', 'ether'),
    to: "0xdD0DC6FB59E100ee4fA9900c2088053bBe14DE92",
    gasLimit: utils.parseUnits('21000', 'wei'),
});

module.exports = signaturePromise;

const { Wallet, utils, providers } = require('ethers');
const { ganacheProvider, PRIVATE_KEY } = require('./config');

const provider = undefined; 

const wallet = new Wallet(PRIVATE_KEY);

async function sendEther({ value, to }) {
    const rawTx = await wallet.signTransaction({ 
        value, to, 
        gasLimit: 0x5208,
        gasPrice: 0x3b9aca00 
    });

    const provider = new providers.Web3Provider(ganacheProvider);
    resp = await provider.sendTransaction(rawTx);
    return resp;
}

module.exports = sendEther;

const { Wallet, utils, providers } = require('ethers');
const { ganacheProvider, PRIVATE_KEY } = require('./config');

const provider = new providers.Web3Provider(ganacheProvider);
const wallet = new Wallet(PRIVATE_KEY, provider);

async function sendEther({ value, to }) {
    return wallet.sendTransaction({ value, to });
}

module.exports = sendEther;

const { Wallet, providers } = require('ethers');
const { ganacheProvider } = require('./config');

const provider = new providers.Web3Provider(ganacheProvider);

function findMyBalance(privateKey) {
    const wallet = new Wallet(privateKey, provider);
    return wallet.getBalance();
}

module.exports = findMyBalance;

const { utils, providers, Wallet } = require('ethers');
const { ganacheProvider } = require('./config');

const provider = new providers.Web3Provider(ganacheProvider);

/**
 * Donate at least 1 ether from the wallet to each charity
 * @param   {string} a hex string private key for a wallet with 10 ETH
 * @param   {array} an array of ethereum charity addresses 
 *
 * @returns {Promise} a promise that resolves after all donations have been sent
 */
async function donate(privateKey, charities) {
    const wallet = new Wallet(privateKey, provider);
    let resps = [];
    nonce = await wallet.getTransactionCount();
    for (let i = 0; i < charities.length; i++) {
        const rawTx = await wallet.signTransaction({
            value: utils.parseEther('1', 'ether'),
            to: charities[i],
            gasLimit: utils.parseUnits('21000', 'wei'),
            nonce: nonce + i
        });
        resps.push(provider.sendTransaction(rawTx));
    }

    return Promise.all(resps);
}

module.exports = donate;

const { providers } = require('ethers');
const { ganacheProvider } = require('./config');

const provider = new providers.Web3Provider(ganacheProvider);

/**
 * Given an ethereum address find all the addresses
 * that were sent ether from that address
 * @param {string} address - The hexidecimal address for the sender
 * @async
 * @returns {Array} all the addresses that receieved ether
 */
async function findEther(address) {
    let addrs = [];
    let blockNum = await provider.getBlockNumber();
    for (let i = 0; i <= blockNum; i++) {
        let block = await provider.getBlockWithTransactions(i);
        block.transactions.forEach((tx) => {
            if (tx.from === address) {
                addrs.push(tx.to);
            }
        });
    }
    return addrs;
}

module.exports = findEther;

1 - Blockchain Cryptography

const { sha256 } = require("ethereum-cryptography/sha256");
const { toHex, utf8ToBytes } = require("ethereum-cryptography/utils");

// the possible colors that the hash could represent
const COLORS = ['red', 'green', 'blue', 'yellow', 'pink', 'orange'];

// given a hash, return the color that created the hash
function findColor(hash) {
    hex = toHex(hash);
    for (let i = 0; i < COLORS.length; i++) {
        b = utf8ToBytes(COLORS[i]);
        h = sha256(b);
        if (toHex(h) === hex) {
            return COLORS[i];
        }
    }
}

module.exports = findColor;

Digital Signatures

const { keccak256 } = require("ethereum-cryptography/keccak");
const { utf8ToBytes } = require("ethereum-cryptography/utils");

function hashMessage(message) {
    return keccak256(utf8ToBytes(message));
}

module.exports = hashMessage;

const secp = require("ethereum-cryptography/secp256k1");
const hashMessage = require('./hashMessage');

const PRIVATE_KEY = "6b911fd37cdf5c81d4c0adb1ab7fa822ed253ab0ad9aa18d77257c88b29b718e";

async function signMessage(msg) {
    return secp.sign(hashMessage(msg), PRIVATE_KEY, { recovered: true });
}

module.exports = signMessage;

const secp = require("ethereum-cryptography/secp256k1");
const hashMessage = require("./hashMessage");

async function recoverKey(message, signature, recoveryBit) {
    return secp.recoverPublicKey(hashMessage(message), signature, recoveryBit);
}

module.exports = recoverKey;

const secp = require("ethereum-cryptography/secp256k1");
const { keccak256 } = require("ethereum-cryptography/keccak");

function getAddress(publicKey) {
    return keccak256(publicKey.slice(1)).slice(-20);
}

module.exports = getAddress;

Proof of Work

const SHA256 = require('crypto-js/sha256');
const TARGET_DIFFICULTY = BigInt(0x0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
const MAX_TRANSACTIONS = 10;

const mempool = [];
const blocks = [];

function addTransaction(transaction) {
    mempool.push(transaction);
}

function mine() {
}

module.exports = {
    TARGET_DIFFICULTY,
    MAX_TRANSACTIONS,
    addTransaction,
    mine,
    blocks,
    mempool
};

const SHA256 = require('crypto-js/sha256');
const TARGET_DIFFICULTY = BigInt(0x0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
const MAX_TRANSACTIONS = 10;

const mempool = [];
const blocks = [];

function addTransaction(transaction) {
    mempool.push(transaction);
}

function mine() {
    let block = { id: blocks.length };
    blocks.push(block);
}

module.exports = {
    TARGET_DIFFICULTY,
    MAX_TRANSACTIONS,
    addTransaction,
    mine,
    blocks,
    mempool
};

const SHA256 = require('crypto-js/sha256');
const TARGET_DIFFICULTY = BigInt(0x0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
const MAX_TRANSACTIONS = 10;

const mempool = [];
const blocks = [];

function addTransaction(transaction) {
    mempool.push(transaction);
}

function mine() {
    let block = { id: blocks.length };
    block.hash = SHA256(JSON.stringify(block));
    blocks.push(block);
}

module.exports = {
    TARGET_DIFFICULTY,
    MAX_TRANSACTIONS,
    addTransaction,
    mine,
    blocks,
    mempool
};

const SHA256 = require('crypto-js/sha256');
const TARGET_DIFFICULTY = BigInt(0x0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
const MAX_TRANSACTIONS = 10;

const mempool = [];
const blocks = [];

function addTransaction(transaction) {
    mempool.push(transaction);
}

function mine() {
    let block = { id: blocks.length, transactions: [] };
    if (mempool.length > 0) {
        for (let i = 0; i < MAX_TRANSACTIONS; i++) {
            block.transactions.push(mempool[0]);
            mempool.shift();
            if (mempool.length <= 0) {
                break;
            }
        }
    }
    block.hash = SHA256(JSON.stringify(block));
    blocks.push(block);
}

module.exports = {
    TARGET_DIFFICULTY,
    MAX_TRANSACTIONS,
    addTransaction,
    mine,
    blocks,
    mempool
};

const SHA256 = require('crypto-js/sha256');
const TARGET_DIFFICULTY = BigInt(0x0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
const MAX_TRANSACTIONS = 10;

const mempool = [];
const blocks = [];

function addTransaction(transaction) {
    mempool.push(transaction);
}

function mine() {
    let block = { id: blocks.length, transactions: [] };
    if (mempool.length > 0) {
        for (let i = 0; i < MAX_TRANSACTIONS; i++) {
            block.transactions.push(mempool[0]);
            mempool.shift();
            if (mempool.length <= 0) {
                break;
            }
        }
    }
    block.nonce = 0;
    block.hash = SHA256(JSON.stringify(block));
    let hash = block.hash;
    while (BigInt(`0x${hash}`) >= TARGET_DIFFICULTY) {
        block.nonce = block.nonce + 1;
        block.hash = SHA256(JSON.stringify(block));
        hash = block.hash;
    }
    blocks.push(block);
}

module.exports = {
    TARGET_DIFFICULTY,
    MAX_TRANSACTIONS,
    addTransaction,
    mine,
    blocks,
    mempool
};

Blockchain Network

const SHA256 = require('crypto-js/sha256');

class Block {
    constructor() {
    }
    toHash() {
        return SHA256("a string");
    }
}

module.exports = Block;

const SHA256 = require('crypto-js/sha256');

class Block {
    constructor(data) {
        this.data = data;
    }
    toHash() {
        return SHA256(this.data.toString());
    }
}

module.exports = Block;

const Block = require('./Block');

class Blockchain {
    constructor() {
        this.chain = [new Block("Genesis")];
    }
}

module.exports = Blockchain;

const Block = require('./Block');

class Blockchain {
    constructor() {
        this.chain = [new Block("Genesis")];
    }

    addBlock(block) {
        this.chain.push(block);
    }
}

module.exports = Blockchain;

cái này có 2 code ở 2 mục nhé

mục Blockchain.js

const Block = require('./Block');

class Blockchain {
    constructor() {
        this.chain = [new Block("Genesis")];
    }

    addBlock(block) {
        block.previousHash = this.chain[this.chain.length - 1].toHash();
        this.chain.push(block);
    }
}

module.exports = Blockchain;

mục Block.js

const SHA256 = require('crypto-js/sha256');

class Block {
    constructor(data) {
        this.data = data;
    }
    toHash() {
        if (this.previousHash) {
            return SHA256(this.data.toString() + this.previousHash.toString());
        } else {
            return SHA256(this.data.toString());
        }
    }
}

module.exports = Block;

const Block = require('./Block');

class Blockchain {
    constructor() {
        this.chain = [new Block("Genesis")];
    }

    addBlock(block) {
        block.previousHash = this.chain[this.chain.length - 1].toHash();
        this.chain.push(block);
    }

    isValid() {
        for (let i = 0; i < this.chain.length; i++) {
            if ((i + 1) >= this.chain.length) {
                break;
            }
            if (this.chain[i].toHash().toString() !== this.chain[i + 1].previousHash.toString()) {
                return false;
            }
        }
        return true;
    }
}

module.exports = Blockchain;

2 - Blockchain Storage

Keeping Track of Blockchain User State

class TXO {
    constructor(owner, amount) {
        this.owner = owner;
        this.amount = amount;
        this.spent = false;
    }
    spend() {
        this.spent = true;
    }
}

module.exports = TXO;

class Transaction {
    constructor(inputUTXOs, outputUTXOs) {
        this.inputUTXOs = inputUTXOs;
        this.outputUTXOs = outputUTXOs;
    }
    execute() {
        for (let i = 0; i < this.inputUTXOs.length; i++) {
            if (this.inputUTXOs[i].spent) {
                throw new Error("already spent");
            }
        }
    }
}

module.exports = Transaction;

class Transaction {
    constructor(inputUTXOs, outputUTXOs) {
        this.inputUTXOs = inputUTXOs;
        this.outputUTXOs = outputUTXOs;
    }
    execute() {
        for (let i = 0; i < this.inputUTXOs.length; i++) {
            if (this.inputUTXOs[i].spent) {
                throw new Error("already spent");
            }
        }

        let inn = 0;
        for (let i = 0; i < this.inputUTXOs.length; i++) {
            inn = inn + this.inputUTXOs[i].amount;
        }
        let out = 0;
        for (let i = 0; i < this.outputUTXOs.length; i++) {
            out = out + this.outputUTXOs[i].amount;
        }
        if (inn < out) {
            throw new Error("less than");
        }
    }
}

module.exports = Transaction;

class Transaction {
    constructor(inputUTXOs, outputUTXOs) {
        this.inputUTXOs = inputUTXOs;
        this.outputUTXOs = outputUTXOs;
    }
    execute() {
        for (let i = 0; i < this.inputUTXOs.length; i++) {
            if (this.inputUTXOs[i].spent) {
                throw new Error("already spent");
            }
        }

        let inn = 0;
        for (let i = 0; i < this.inputUTXOs.length; i++) {
            inn = inn + this.inputUTXOs[i].amount;
        }
        let out = 0;
        for (let i = 0; i < this.outputUTXOs.length; i++) {
            out = out + this.outputUTXOs[i].amount;
        }
        if (inn < out) {
            throw new Error("less than");
        }

        for (let i = 0; i < this.inputUTXOs.length; i++) {
            this.inputUTXOs[i].spend();
        }
    }
}

module.exports = Transaction;

class Transaction {
    constructor(inputUTXOs, outputUTXOs) {
        this.inputUTXOs = inputUTXOs;
        this.outputUTXOs = outputUTXOs;
    }
    execute() {
        for (let i = 0; i < this.inputUTXOs.length; i++) {
            if (this.inputUTXOs[i].spent) {
                throw new Error("already spent");
            }
        }

        let inn = 0;
        for (let i = 0; i < this.inputUTXOs.length; i++) {
            inn = inn + this.inputUTXOs[i].amount;
        }
        let out = 0;
        for (let i = 0; i < this.outputUTXOs.length; i++) {
            out = out + this.outputUTXOs[i].amount;
        }
        if (inn < out) {
            throw new Error("less than");
        }

        for (let i = 0; i < this.inputUTXOs.length; i++) {
            this.inputUTXOs[i].spend();
        }

        this.fee = inn - out;
    }
}

module.exports = Transaction;

Tree Data Structures

class Node {
    constructor(data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}

module.exports = Node;

class Tree {
    constructor() {
        this.root = null;
    }
}

module.exports = Tree;

class Tree {
    constructor() {
        this.root = null;
    }

    addNode(node) {
        this.root = node;
    }
}

module.exports = Tree;

class Tree {
    constructor() {
        this.root = null;
    }

    addNode(node) {
        if (this.root === null) {
            this.root = node;
        } else if (this.root.data > node.data) {
            this.root.left = node;
        } else {
            this.root.right = node;
        }
    }
}

module.exports = Tree;

class Tree {
    constructor() {
        this.root = null;
    }

    addNode(node) {
        if (this.root === null) {
            this.root = node;
        } else {
            let p = this.root;
            while (true) {
                if (p.data > node.data) {
                    if (p.left) {
                        p = p.left;
                    } else {
                        p.left = node;
                        break;
                    }
                } else {
                    if (p.right) {
                        p = p.right;
                    } else {
                        p.right = node;
                        break;
                    }
                }
            }
        }
    }
}

module.exports = Tree;

class Tree {
    constructor() {
        this.root = null;
    }

    addNode(node) {
        if (this.root === null) {
            this.root = node;
        } else {
            let p = this.root;
            while (true) {
                if (p.data > node.data) {
                    if (p.left) {
                        p = p.left;
                    } else {
                        p.left = node;
                        break;
                    }
                } else {
                    if (p.right) {
                        p = p.right;
                    } else {
                        p.right = node;
                        break;
                    }
                }
            }
        }
    }

    hasNode(number) {
        let n = this.root;
        while (n) {
            if (n.data === number) {
                return true;
            } else {
                if (n.data > number) {
                    n = n.left;
                } else {
                    n = n.right;
                }
            }
        }
        return false;
    }
}

module.exports = Tree;

class MerkleTree {
    constructor(leaves, concat) {
        this.leaves = leaves;
        this.concat = concat;
    }
    getRoot() {
        return this.concat(this.leaves[0], this.leaves[1]);
    }
}

module.exports = MerkleTree;

class MerkleTree {
    constructor(leaves, concat) {
        this.leaves = leaves;
        this.concat = concat;
    }
    getRoot(next = this.leaves) {
        while (true) {
            if (next.length <= 1) {
                return next;
            }
            let level = [];
            for (let i = 0; i < next.length; i += 2) {
                level.push(this.concat(next[i], next[i + 1]));
            }
            next = level;
        }
    }
}

module.exports = MerkleTree;

class MerkleTree {
    constructor(leaves, concat) {
        this.leaves = leaves;
        this.concat = concat;
    }
    getRoot(next = this.leaves) {
        while (true) {
            if (next.length <= 1) {
                return next;
            }
            let level = [];
            for (let i = 0; i < next.length; i += 2) {
                if ((i + 1) >= next.length) {
                    level.push(next[i]);
                } else {
                    level.push(this.concat(next[i], next[i + 1]));
                }
            }
            next = level;
        }
    }
}

module.exports = MerkleTree;

class MerkleTree {
    constructor(leaves, concat) {
        this.leaves = leaves;
        this.concat = concat;
    }
    getRoot(next = this.leaves) {
        while (true) {
            if (next.length <= 1) {
                return next;
            }
            let level = [];
            for (let i = 0; i < next.length; i += 2) {
                if ((i + 1) >= next.length) {
                    level.push(next[i]);
                } else {
                    level.push(this.concat(next[i], next[i + 1]));
                }
            }
            next = level;
        }
    }
    getProof(index, next = this.leaves) {
        let proof = [];
        while (true) {
            if (next.length <= 1) {
                return proof;
            }
            let level = [];
            for (let i = 0; i < next.length; i += 2) {
                if ((i + 1) >= next.length) {
                    level.push(next[i]);
                } else {
                    level.push(this.concat(next[i], next[i + 1]));
                    if (index === i || i === (index - 1)) {
                        if (index === i) {
                            proof.push({ data: next[i + 1], left: false });
                        } else {
                            proof.push({ data: next[i], left: true });
                        }
                    }
                }
            }
            index = Math.floor(index / 2);
            next = level;
        }
    }
}

module.exports = MerkleTree;

function verifyProof(proof, node, root, concat) {
    let n = node;
    proof.forEach((e, _) => {
        if (e.left) {
            n = concat(e.data, n);
        } else {
            n = concat(n, e.data);
        }
    });

    if (n === root) {
        return true;
    } else {
        return false;
    }
}

module.exports = verifyProof;

Blockchain Data Storage

có 2 mục nhé chú ý :

mục TrieNode.js

class TrieNode {
    constructor(key) {
        this.key = key;
        this.children = {};
        this.isWord = false;
    }
}

module.exports = TrieNode;

mục Trie.js

const TrieNode = require('./TrieNode');

class Trie {
    constructor() {
        this.root = new TrieNode(null);
    }
}

module.exports = Trie;

const TrieNode = require('./TrieNode');

class Trie {
    constructor() {
        this.root = new TrieNode(null);
    }

    insert(data) {
        let n = this.root;
        for (let i = 0; i < data.length; i++) {
            let node = new TrieNode(data[i]);
            n.children[data[i]] = node;
            if ((i + 1) === data.length) {
                node.isWord = true;
            }
            n = node;
        }
    }
}

module.exports = Trie;

const TrieNode = require('./TrieNode');

class Trie {
    constructor() {
        this.root = new TrieNode(null);
    }

    insert(data) {
        let n = this.root;
        for (let i = 0; i < data.length; i++) {
            let node = n.children[data[i]];
            if (!node) {
                node = new TrieNode(data[i]);
            }
            n.children[data[i]] = node;
            if ((i + 1) === data.length) {
                node.isWord = true;
            }
            n = node;
        }
    }
}

module.exports = Trie;

const TrieNode = require('./TrieNode');

class Trie {
    constructor() {
        this.root = new TrieNode(null);
    }

    insert(data) {
        let n = this.root;
        for (let i = 0; i < data.length; i++) {
            let node = n.children[data[i]];
            if (!node) {
                node = new TrieNode(data[i]);
            }
            n.children[data[i]] = node;
            if ((i + 1) === data.length) {
                node.isWord = true;
            }
            n = node;
        }
    }

    contains(word) {
        let n = this.root.children[word[0]];
        if (n === null) {
            return false;
        }
        let i = 1;
        while (n) {
            if (i >= word.length) {
                if (n.isWord) {
                    return true;
                } else {
                    return false;
                }
            }
            n = n.children[word[i]];
            if (n === null) {
                return false;
            }
            i = i + 1;
        }
    }
}

module.exports = Trie;

next qua các phần k phải điền code

hiện tại chỉ có 1 phần nhỏ bài học ra mắt , còn rất nhiều khóa học đằng sau đợi mở nữa nên cứ bình thường mà học

cũng không chắc đã có thưởng cho người học nên ai không thích thì có thể không làm nhé vì nó cũng tốn khá nhiều thời gian của mọi người

mục tiêu : bài viết này được viết ra là để hướng dẫn cho mọi người làm dễ nhất có thể chả cần có kiến thức j cả chỉ cần copy paste để hoàn thành khóa học là được vì không phải ai cũng giỏi và có nhiều thời gian mà tự mò được

mọi người chỉ cần làm theo tất cả các bước bên dưới mở đúng chỗ là làm xong nhé

bắt đầu học nhé :

Bước 1: hôm trước ai đã đăng ký và claim NFT qua link nó gửi về mail tại đây thì vào discord veri và lấy role nhé - link

Bước 2: tiếp theo đăng ký tài khoản bằng google và liên kết ví tại web này ( yêu cầu ví có NFT ở trên ) - link

Bước 3: đăng ký xong mọi người có thể vào profile và cài đặt các thông tin

Bước 4: tiếp theo dưới đây là toàn bộ các đáp án của từng phần trong khóa học hiện tại

phần 1 : javascript fundamentals

A. The Basic - vì nó quá dài nên sẽ chia thành những link nhỏ để xem cho dễ nhé

the basic phần 1 - link

the basic phần 2 - link

the basic phần 3 - link

B. Data Structures - link

C. Networks - link

phần 2 : Ethereum Developer Bootcamp - đợi update soon nhé

phần 1+ 2 - link

phần 3 link

phần 4 - link

phần 5

phần 6

bấm next qua 2 cái trên ảnh

1. đáp án CALLBACK FUNCTIONS

/**
 * Runs a callback function immediately
 * @param {function} callbackFunction
 */
function runCallback(callbackFunction) {
    callbackFunction();
}

module.exports = runCallback;

/**
 * Runs a callback function immediately
 * @param {function} callbackFunction
 */
function runCallback(callbackFunction) {
    setTimeout(callbackFunction, 1000);
}

module.exports = runCallback;

class Dialog {
    onClose(callbackFunction) {
        this.carr = this.carr || [];
        this.carr.push(callbackFunction);
    }

    close() {
        for (let i = 0; i < this.carr.length; i++) {
            this.carr[i]();
        }
    }
}

module.exports = Dialog;

class Dialog {
    onClose(callbackFunction) {
        this.carr = this.carr || [];
        this.carr.push(callbackFunction);
    }

    close() {
        for (let i = 0; i < this.carr.length; i++) {
            this.carr[i]();
        }
    }
}

module.exports = Dialog;

function forEach(arr, callback) {
    for (let i = 0; i < arr.length; i++) {
        callback(arr[i], i);
    }
}

module.exports = forEach;

function map(arr, callback) {
    let a = [];
    for (let i = 0; i < arr.length; i++) {
        a.push(callback(arr[i]));
    }

    return a;
}

module.exports = map;

2. đáp án INTRODUCTION TO PROMISES

code bên dưới

const { makeFood } = require('./Kitchen');

class Order {
    constructor() {
        this.isReady = false;
    }
    request(food) {
        const promise = makeFood(food);
        promise.then( (food) => {
            this.isReady = true;
        });
    }
}

module.exports = Order;

const { makeFood } = require('./Kitchen');

class Order {
    constructor() {
        this.isReady = false;
    }
    request(food) {
        const promise = makeFood(food);
        promise.then((food) => {
            this.isReady = true;
        });
        promise.catch((err) => {
            this.error = err;
        });
    }
}

module.exports = Order;

function timer() {

    const promise = new Promise(function (resolve, reject) {
        setTimeout(function () {
            resolve('resolve');
        }, 1000);
    });

    return promise;
}

module.exports = timer;

function timer() {

    const promise = new Promise(function (resolve, reject) {
        setTimeout(function () {
            resolve('resolve');
        }, 1000);
    });

    return promise;
}

module.exports = timer;

const { getResults } = require('./lab');
const { sendResults } = require('./messaging');
const { logResponse, logError } = require('./logs');

async function handleResults(patientId) {
    try {
        const res = await getResults(patientId);
        const r = await sendResults(patientId, res);
        await logResponse(r);
    } catch (ex) {
        logError(ex);
    }
}

module.exports = handleResults;

const { getResults } = require('./lab');
const { sendResults } = require('./messaging');
const { logResponse, logError } = require('./logs');

async function handleResults(patientId) {
    try {
        const res = await getResults(patientId);
        const r = await sendResults(patientId, res);
        await logResponse(r);
    } catch (ex) {
        logError(ex);
    }
}

module.exports = handleResults;

3. đáp án PACT: A PROMISE LIBRARY

code bên đưới 

class Pact {
    constructor(fn) {
        this.catchs = [];
        this.thens = [];
        this.f1 = (value)=> {
            for (let i = 0; i < this.thens.length; i++) {
                this.thensi;
            }
        };
        this.f2 = (value)=> {
            for (let i = 0; i < this.catchs.length; i++) {
                this.catchsi;
            }
        };
        fn(this.f1, this.f2);
    }
    catch(c) {
        this.catchs.push(c);
    }
    then(t) {
        this.thens.push(t);
    }
}

module.exports = Pact;

code bên dưới 

class Pact {
    constructor(fn) {
        this.catchs = [];
        this.thens = [];
        this.f1 = (value)=> {
            for (let i = 0; i < this.thens.length; i++) {
                this.thensi;
            }
        };
        this.f2 = (value)=> {
            for (let i = 0; i < this.catchs.length; i++) {
                this.catchsi;
            }
        };
        fn(this.f1, this.f2);
    }
    catch(c) {
        this.catchs.push(c);
    }
    then(t) {
        this.thens.push(t);
    }
}

module.exports = Pact;

code bên dưới

class Pact {
    constructor(fn) {
        this.catchs = [];
        this.thens = [];
        this.f1 = (value)=> {
            for (let i = 0; i < this.thens.length; i++) {
                this.thensi;
            }
        };
        this.f2 = (value)=> {
            for (let i = 0; i < this.catchs.length; i++) {
                this.catchsi;
            }
        };
        fn(this.f1, this.f2);
    }
    catch(c) {
        this.catchs.push(c);
    }
    then(t) {
        this.thens.push(t);
    }
}

module.exports = Pact;

code bên dưới

class Pact {
    constructor(fn) {
        this.catchs = [];
        this.thens = [];
        this.f1 = (value)=> {
            for (let i = 0; i < this.thens.length; i++) {
                this.thensi;
            }
        };
        this.f2 = (value)=> {
            for (let i = 0; i < this.catchs.length; i++) {
                this.catchsi;
            }
        };
        fn(this.f1, this.f2);
    }
    catch(c) {
        this.catchs.push(c);
    }
    then(t) {
        this.thens.push(t);
    }
}

module.exports = Pact;

code bên dưới 

class Pact {
    constructor(fn) {
        this.catchs = [];
        this.thens = [];
        this.f1 = (value)=> {
            for (let i = 0; i < this.thens.length; i++) {
                this.thensi;
            }
        };
        this.f2 = (value)=> {
            for (let i = 0; i < this.catchs.length; i++) {
                this.catchsi;
            }
        };
        fn(this.f1, this.f2);
    }
    catch(c) {
        this.catchs.push(c);
    }
    then(t) {
        this.thens.push(t);
    }
}

module.exports = Pact;

code bên dưới 

const STATUS = {
    PENDING: 0,
    RESOLVED: 1,
    REJECTED: 2,
}

class Pact {
    constructor(fn) {
        this.catchs = [];
        this.thens = [];
        this.status = STATUS.PENDING;
        this.f1 = (value)=> {
            this.resolvedValue = value;
            this.status = STATUS.RESOLVED;
            for (let i = 0; i < this.thens.length; i++) {
                this.thensi;
            }
        };
        this.f2 = (value)=> {
            this.rejectedValue = value;
            this.status = STATUS.REJECTED;
            for (let i = 0; i < this.catchs.length; i++) {
                this.catchsi;
            }
        };
        fn(this.f1, this.f2);
    }
    catch(c) {
        if (this.status === STATUS.PENDING) {
            this.catchs.push(c);
        }
        else if (this.status === STATUS.REJECTED) {
            c(this.rejectedValue);
        }
    }
    then(t) {
        if (this.status === STATUS.PENDING) {
            this.thens.push(t);
        }
        else if (this.status === STATUS.RESOLVED) {
            t(this.resolvedValue);
        }
    }
}

module.exports = Pact;

code bên dưới 

const STATUS = {
    PENDING: 0,
    RESOLVED: 1,
    REJECTED: 2,
}

class Pact {
    constructor(fn) {
        this.catchs = [];
        this.thens = [];
        this.status = STATUS.PENDING;
        this.f1 = (value)=> {
            this.resolvedValue = value;
            this.status = STATUS.RESOLVED;
            for (let i = 0; i < this.thens.length; i++) {
                this.thensi;
            }
        };
        this.f2 = (value)=> {
            this.rejectedValue = value;
            this.status = STATUS.REJECTED;
            for (let i = 0; i < this.catchs.length; i++) {
                this.catchsi;
            }
        };
        fn(this.f1, this.f2);
    }
    catch(c) {
        if (this.status === STATUS.PENDING) {
            this.catchs.push(c);
        }
        else if (this.status === STATUS.REJECTED) {
            c(this.rejectedValue);
        }
    }
    then(t) {
        if (this.status === STATUS.PENDING) {
            return new Pact((resolve, reject) => {
                this.thens.push((val) => {
                    if (val instanceof Pact) {
                        val.then((val) => resolve(t(val)));
                    }
                    else {
                        resolve(t(val));
                    }
                });
            });
        }
        else if (this.status === STATUS.RESOLVED) {
            t(this.resolvedValue);
        }
    }
}

module.exports = Pact;

code bên dưới 

const STATUS = {
    PENDING: 0,
    RESOLVED: 1,
    REJECTED: 2,
}

class Pact {
    constructor(fn) {
        this.catchs = [];
        this.thens = [];
        this.status = STATUS.PENDING;
        this.f1 = (value)=> {
            this.resolvedValue = value;
            this.status = STATUS.RESOLVED;
            for (let i = 0; i < this.thens.length; i++) {
                this.thensi;
            }
        };
        this.f2 = (value)=> {
            this.rejectedValue = value;
            this.status = STATUS.REJECTED;
            for (let i = 0; i < this.catchFn.length; i++) {
                this.catchsi;
            }
        };
        fn(this.f1, this.f2);
    }
    catch(c) {
        if (this.status === STATUS.PENDING) {
            this.catchs.push(c);
        }
        else if (this.status === STATUS.REJECTED) {
            c(this.rejectedValue);
        }
    }
    then(t) {
        if (this.status === STATUS.PENDING) {
            return new Pact((resolve, reject) => {
                this.thens.push((val) => {
                    if (val instanceof Pact) {
                        val.then((val) => resolve(t(val)));
                    }
                    else {
                        resolve(t(val));
                    }
                });
            });
        }
        else if (this.status === STATUS.RESOLVED) {
            t(this.resolvedValue);
        }
    }
}

module.exports = Pact;

vào xem và next qua 2 mục này là kết thúc phần network

function sortUp(array) {
    return array.sort(function comparison(a, b) {
        if (b < a) {
            return 1;
        }
        if (a < b) {
            return -1;
        }
        return 0;
    });
}

module.exports = sortUp;

function sortDown(array) {
    return array.sort(function comparison(a, b) {
        if (b < a) {
            return -1;
        }
        if (a < b) {
            return 1;
        }
        return 0;
    });
}

module.exports = sortDown;

function sortStringsUp(array) {
    return array.sort(function comparison(a, b) {
        return a.localeCompare(b);
    });
}

module.exports = sortStringsUp;

function sortStringsDown(array) {
    return array.sort(function comparison(a, b) {
        if (a.localeCompare(b) === 1) {
            return -1;
        }
        if (a.localeCompare(b) === -1) {
            return 1;
        }
        return a.localeCompare(b);
    });
}

module.exports = sortStringsDown;

function sortStudents(students) {
    return students.sort(function comparison(a, b) {
        if (a.graduated !== b.graduated) {
            if (a.graduated) {
                return -1;
            } else {
                return 1;
            }
        }
        if (a.grade > b.grade) {
            return -1;
        }
        if (a.grade < b.grade) {
            return 1;
        }
        return 0;
    });
}

module.exports = sortStudents;

const MONTHS = [
    'JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN',
    'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC'
];

function sortByMonth(events) {
    return events.sort(function comparison(a, b) {
        let ai = MONTHS.indexOf(a.month);
        let bi = MONTHS.indexOf(b.month);
        if (ai < bi) {
            return -1;
        }
        if (ai > bi) {
            return 1;
        }
        return 0;
    });
}

module.exports = sortByMonth;

2. đáp án ARRAY MAP

function plusOne(arr) {
    return arr.map(function (x) {
        return (x + 1);
    });
}

module.exports = plusOne;

function squareRoot(arr) {
    return arr.map(function (x) {
        return Math.sqrt(x);
    });
}

module.exports = squareRoot;

/**
 * Given a number n, square it.
 *
 * @param {number} n 
 * @return {number} n squared
 */
function squared(n) {
    return (n * n);
}

module.exports = squared;

const squared = require('./squared');

function squaredMap(arr) {
    return arr.map(squared);
}

module.exports = squaredMap;

function addScore(players) {
    let i = 0;

    return players.map(function (player) {
        i++;
        let one = player;
        if (i < 4) {
            one.score = one.score + 10;
        }

        return one;
    });
}

module.exports = addScore;

function addScore(players) {
    let i = 0;

    return players.map(function (player) {
        i++;
        let one = player;
        if (i < 4) {
            one.score = one.score + 10;
        }

        return one;
    });
}

module.exports = addScore;

3. đáp án ARRAY FILTER

function lessThanFive(array) {
    return array.filter(function (e) {
        return (e < 5);
    });
}

module.exports = lessThanFive;

function onlyTrue(array) {
    return array.filter(function (e) {
        return e;
    });
}

module.exports = onlyTrue;

function shortStrings(array) {
    return array.filter(function (e) {
        return (e.length <= 3);
    });
}

module.exports = shortStrings;

function topStudents(array) {
    return array.filter(function (e) {
        return (e.grade >= 90);
    });
}

module.exports = topStudents;

function firstThree(array) {
    let i = 0;
    return array.filter(function (e) {
        i++;
        if (i < 4) {
            return true;
        } else {
            return false;
        }
    });
}

module.exports = firstThree;

function unique(array) {
    let a = [];
    return array.filter(function (e) {
        if (a.indexOf(e) === -1) {
            a.push(e);
            return true;
        }
        return false;
    });
}

module.exports = unique;

4. đáp án ARRAY REDUCE

// numbers is an array full of numbers
// let's add all the numbers and return the sum
// i.e. [1,2,3,4,5] => 15
function sum(numbers) {
    return numbers.reduce((accumulator, currentValue) => {
        accumulator = accumulator + currentValue;
        return accumulator;
    });
}

module.exports = sum;

// numbers is an array full of numbers
// let's find the largest and return it
// i.e. [2,3,5,1,4] => 5
function largest(numbers) {
    return numbers.reduce((accumulator, currentValue) => {
        if (accumulator > currentValue) {
            return accumulator;
        } else {
            return currentValue;
        }
    }, 1);
}

module.exports = largest;

// numbers is an array full of numbers
// let's find the largest and return it
// i.e. [2,3,5,1,4] => 5
function largest(numbers) {
    return numbers.reduce((accumulator, currentValue) => {
        if (accumulator > currentValue) {
            return accumulator;
        } else {
            return currentValue;
        }
    }, 1);
}

module.exports = largest;

// numbers is an array full of numbers
// let's remove any duplicates and return it
// i.e. [2,2,3,5,1,3,4] => [2,3,5,1,4]
function removeDuplicates(numbers) {
    return numbers.reduce((accumulator, currentValue) => {
        if (-1 === accumulator.indexOf(currentValue)) {
            accumulator.push(currentValue);
        }
        return accumulator;
    }, []);
}

module.exports = removeDuplicates;

// food is an array full of food objects
// let's group them by "type" and return them
function group(foods) {
    return foods.reduce((accumulator, currentValue) => {
        accumulator[currentValue.type] = accumulator[currentValue.type] || [];
        accumulator[currentValue.type].push(currentValue.food);
        return accumulator;
    }, {});
}

module.exports = group;

// numbers is an array full of integers
// let's figure if all the numbers are unique
// i.e. [1,2,3,1] => false
// [1,2,3] => true
function allUnique(numbers) {
    return numbers.reduce((accumulator, currentValue, index) => {
        if (!accumulator) {
            return false;
        }
        c = numbers.indexOf(currentValue);
        return (c === index);
    }, true);
}

module.exports = allUnique;

5. đáp án RECURSION

function factorial(n) {
    if (n === 1) {
        return 1;
    }

    return n * factorial(n - 1);
}

module.exports = factorial;

function factorial(n) {
    if (n === 1) {
        return 1;
    }

    return n * factorial(n - 1);
}

module.exports = factorial;

function factorial(n) {
    if (n === 1) {
        return 1;
    }

    return n * factorial(n - 1);
}

module.exports = factorial;

function walk(node) {
    if (node.next) {
        return walk(node.next);
    } else {
        return node;
    }
}

module.exports = walk;

function walk(node) {
    if (node.next) {
        return walk(node.next);
    } else {
        return node;
    }
}

module.exports = walk;

6. đáp án STACKS: UNDO & REDO OPERATIONS

const { MAX_STACK_SIZE } = require('./config');

class Stack {
    constructor() {
        this.items = [];
    }
    push(item) {
        if (this.items.length >= MAX_STACK_SIZE) {
            throw new Error("size Overflow error");
        }
        this.items.push(item);
    }
    pop() {
        if (this.items.length === 0) {
            throw new Error("0 item error");
        }
        return this.items.pop();
    }
    isEmpty() {
        return (this.items.length === 0);
    }
    peek() {
        if (this.isEmpty()) {
            return;
        }
        return this.items[this.items.length - 1];
    }
}

module.exports = Stack;

const { MAX_STACK_SIZE } = require('./config');

class Stack {
    constructor() {
        this.items = [];
    }
    push(item) {
        if (this.items.length >= MAX_STACK_SIZE) {
            throw new Error("size Overflow error");
        }
        this.items.push(item);
    }
    pop() {
        if (this.items.length === 0) {
            throw new Error("0 item error");
        }
        return this.items.pop();
    }
    isEmpty() {
        return (this.items.length === 0);
    }
    peek() {
        if (this.isEmpty()) {
            return;
        }
        return this.items[this.items.length - 1];
    }
}

module.exports = Stack;

const { MAX_STACK_SIZE } = require('./config');

class Stack {
    constructor() {
        this.items = [];
    }
    push(item) {
        if (this.items.length >= MAX_STACK_SIZE) {
            throw new Error("size Overflow error");
        }
        this.items.push(item);
    }
    pop() {
        if (this.items.length === 0) {
            throw new Error("0 item error");
        }
        return this.items.pop();
    }
    isEmpty() {
        return (this.items.length === 0);
    }
    peek() {
        if (this.isEmpty()) {
            return;
        }
        return this.items[this.items.length - 1];
    }
}

module.exports = Stack;

const Stack = require('./Stack');

class OperationManager {
    constructor() {
        this.operations = new Stack();
        this.undos = new Stack();
    }

    addOperation(operation) {
        this.operations.push(operation);
    }

    undo() {
        this.undos.push(this.operations.pop());
    }

    redo() {
        this.operations.push(this.undos.pop());
    }

    redoAll() {
        while (!this.undos.isEmpty()) {
            this.operations.push(this.undos.pop());
        }
    }
}

module.exports = OperationManager;

const Stack = require('./Stack');

class OperationManager {
    constructor() {
        this.operations = new Stack();
        this.undos = new Stack();
    }

    addOperation(operation) {
        this.operations.push(operation);
    }

    undo() {
        this.undos.push(this.operations.pop());
    }

    redo() {
        this.operations.push(this.undos.pop());
    }

    redoAll() {
        while (!this.undos.isEmpty()) {
            this.operations.push(this.undos.pop());
        }
    }
}

module.exports = OperationManager;

const Stack = require('./Stack');

class OperationManager {
    constructor() {
        this.operations = new Stack();
        this.undos = new Stack();
    }

    addOperation(operation) {
        this.operations.push(operation);
    }

    undo() {
        this.undos.push(this.operations.pop());
    }

    redo() {
        this.operations.push(this.undos.pop());
    }

    redoAll() {
        while (!this.undos.isEmpty()) {
            this.operations.push(this.undos.pop());
        }
    }
}

module.exports = OperationManager;

7. đáp án LINKED LIST

class Node {
    constructor(data) {
        this.data = data;
        this.next = null;
    }
}

module.exports = Node;

class LinkedList {
    constructor() {
        this.head = null;
    }

    addFirst(node) {
        node.next = this.head;
        this.head = node;
    }

    addLast(node) {
        if (this.head === null) {
            this.head = node;
            return;
        }

        let last = this.head;
        while (last.next !== null) {
            last = last.next;
        }
        last.next = node;
    }

    indexOf(node) {
        let i = 0;
        for (let p = this.head; p !== null; p = p.next) {
            if (node === p) {
                return i;
            }
            i = i + 1;
        }

        return -1;
    }

    removeAt(index) {
        if (this.head === null) {
            return;
        }
        if (index === 0) {
            this.head = this.head.next;
            return;
        }

        let i = 1;
        let p = this.head;
        let n = this.head.next;
        while (n) {
            if (i === index) {
                p.next = n.next;
                return;
            }
            p = p.next;
            n = n.next;
            i++;
        }
    }
}

module.exports = LinkedList;

class LinkedList {
    constructor() {
        this.head = null;
    }

    addFirst(node) {
        node.next = this.head;
        this.head = node;
    }

    addLast(node) {
        if (this.head === null) {
            this.head = node;
            return;
        }

        let last = this.head;
        while (last.next !== null) {
            last = last.next;
        }
        last.next = node;
    }

    indexOf(node) {
        let i = 0;
        for (let p = this.head; p !== null; p = p.next) {
            if (node === p) {
                return i;
            }
            i = i + 1;
        }

        return -1;
    }

    removeAt(index) {
        if (this.head === null) {
            return;
        }
        if (index === 0) {
            this.head = this.head.next;
            return;
        }

        let i = 1;
        let p = this.head;
        let n = this.head.next;
        while (n) {
            if (i === index) {
                p.next = n.next;
                return;
            }
            p = p.next;
            n = n.next;
            i++;
        }
    }
}

module.exports = LinkedList;

class LinkedList {
    constructor() {
        this.head = null;
    }

    addFirst(node) {
        node.next = this.head;
        this.head = node;
    }

    addLast(node) {
        if (this.head === null) {
            this.head = node;
            return;
        }

        let last = this.head;
        while (last.next !== null) {
            last = last.next;
        }
        last.next = node;
    }

    indexOf(node) {
        let i = 0;
        for (let p = this.head; p !== null; p = p.next) {
            if (node === p) {
                return i;
            }
            i = i + 1;
        }

        return -1;
    }

    removeAt(index) {
        if (this.head === null) {
            return;
        }
        if (index === 0) {
            this.head = this.head.next;
            return;
        }

        let i = 1;
        let p = this.head;
        let n = this.head.next;
        while (n) {
            if (i === index) {
                p.next = n.next;
                return;
            }
            p = p.next;
            n = n.next;
            i++;
        }
    }
}

module.exports = LinkedList;

class LinkedList {
    constructor() {
        this.head = null;
    }

    addFirst(node) {
        node.next = this.head;
        this.head = node;
    }

    addLast(node) {
        if (this.head === null) {
            this.head = node;
            return;
        }

        let last = this.head;
        while (last.next !== null) {
            last = last.next;
        }
        last.next = node;
    }

    indexOf(node) {
        let i = 0;
        for (let p = this.head; p !== null; p = p.next) {
            if (node === p) {
                return i;
            }
            i = i + 1;
        }

        return -1;
    }

    removeAt(index) {
        if (this.head === null) {
            return;
        }
        if (index === 0) {
            this.head = this.head.next;
            return;
        }

        let i = 1;
        let p = this.head;
        let n = this.head.next;
        while (n) {
            if (i === index) {
                p.next = n.next;
                return;
            }
            p = p.next;
            n = n.next;
            i++;
        }
    }
}

module.exports = LinkedList;

class LinkedList {
    constructor() {
        this.head = null;
    }

    addFirst(node) {
        node.next = this.head;
        this.head = node;
    }

    addLast(node) {
        if (this.head === null) {
            this.head = node;
            return;
        }

        let last = this.head;
        while (last.next !== null) {
            last = last.next;
        }
        last.next = node;
    }

    indexOf(node) {
        let i = 0;
        for (let p = this.head; p !== null; p = p.next) {
            if (node === p) {
                return i;
            }
            i = i + 1;
        }

        return -1;
    }

    removeAt(index) {
        if (this.head === null) {
            return;
        }
        if (index === 0) {
            this.head = this.head.next;
            return;
        }

        let i = 1;
        let p = this.head;
        let n = this.head.next;
        while (n) {
            if (i === index) {
                p.next = n.next;
                return;
            }
            p = p.next;
            n = n.next;
            i++;
        }
    }
}

module.exports = LinkedList;

class LinkedList {
    constructor() {
        this.head = null;
    }

    addFirst(node) {
        node.next = this.head;
        this.head = node;
    }

    addLast(node) {
        if (this.head === null) {
            this.head = node;
            return;
        }

        let last = this.head;
        while (last.next !== null) {
            last = last.next;
        }
        last.next = node;
    }

    indexOf(node) {
        let i = 0;
        for (let p = this.head; p !== null; p = p.next) {
            if (node === p) {
                return i;
            }
            i = i + 1;
        }

        return -1;
    }

    removeAt(index) {
        if (this.head === null) {
            return;
        }
        if (index === 0) {
            this.head = this.head.next;
            return;
        }

        let i = 1;
        let p = this.head;
        let n = this.head.next;
        while (n) {
            if (i === index) {
                p.next = n.next;
                return;
            }
            p = p.next;
            n = n.next;
            i++;
        }
    }
}

module.exports = LinkedList;

8. đáp án DEEP RETRIEVAL

// retrieve a prop that is deeply nested within objects
// i.e. { prop: { prop: { prop: 3 }}} => 3
function deepRetrieval(obj) {
    if ("object" === typeof (obj.prop)) {
        return deepRetrieval(obj.prop);
    }

    return obj.prop;
}

module.exports = deepRetrieval;

vậy là kết thúc phần

function eitherNotBoth(num) {
    if (num % 5 === 0) {
        if (num % 3 === 0) {
            return false;
        } else {
            return true;
        }
    } else {
        if (num % 3 === 0) {
            return true;
        } else {
            return false;
        }
    }
}

module.exports = eitherNotBoth;

function fizzBuzz(numbers) {
    let str = "";

    for (let i = 0; i < numbers.length; i++) {
        if ((numbers[i] % 3 === 0) && (numbers[i] % 5 === 0)) {
            str += "fizzbuzz";
        } else if (numbers[i] % 5 === 0) {
            str += "buzz";

        } else if (numbers[i] % 3 === 0) {
            str += "fizz";
        }
    }

    return str;
}

module.exports = fizzBuzz;

2. đáp án THIS KEYWORD

function thisName() {
    return this.name;
}

const newFunction = thisName.bind({ name: 'Bob' });

module.exports = newFunction;

function thisName() {
    return this.name;
}

const newFunction = thisName.bind({ name: 'Bob' });

module.exports = newFunction;

const obj = {
    name: 'Bob',
    getName: function () {
        return this.name;
    }
}

module.exports = obj;

const fetchAge = require('./fetchAge');

function Celebrity(name) {
    this.name = name;
    const that = this;
    fetchAge(this.name, function (age) {
        that.age = age;
    });
}

module.exports = Celebrity;

đáp án PROTOTYPE CHAIN

// Our Shape "Constructor"
function Shape(x, y) {
    // store x and y in this.position
    this.position = {x, y};
    this.position.x = x;
    this.position.y = y;
}

module.exports = Shape;

// Our Shape "Constructor"
function Shape(x, y) {
    this.position = {x, y};
    this.position.x = x;
    this.position.y = y;
}

    Shape.prototype.move = function(a, b) {
        this.position.x += a;
        this.position.y += b;
    }

module.exports = Shape;

const Shape = require('./Shape');

function Circle(x, y, radius) {
    Shape.call(this, x, y);
    this.radius = radius;
}

module.exports = Circle;

const Shape = require('./Shape');

function Circle(x, y, radius) {
    Shape.call(this, x, y);
    this.radius = radius;
    Circle.prototype = Object.create(Shape.prototype);
}

module.exports = Circle;

const Shape = require('./Shape');

function Rectangle(x, y, height, width) {
    Shape.call(this, x, y);
    this.height = height;
    this.width = width;
    Rectangle.prototype = Object.create(Shape.prototype);
    Rectangle.prototype.flip = function () {
        let t = this.width;
        this.width = this.height;
        this.height = t;
    }
}

module.exports = Rectangle;

const Shape = require('./Shape');

function Rectangle(x, y, height, width) {
    Shape.call(this, x, y);
    this.height = height;
    this.width = width;
    Rectangle.prototype = Object.create(Shape.prototype);
    Rectangle.prototype.flip = function () {
        let t = this.width;
        this.width = this.height;
        this.height = t;
    }
}

module.exports = Rectangle;

đáp án classes

class Hero {
    constructor() {
        this.health = 50;
    }
    takeDamage(health) {
        this.health -= health;
    }
}

module.exports = Hero;

class Hero {
    constructor() {
        this.health = 50;
    }
    takeDamage(health) {
        this.health -= health;
    }
}

module.exports = Hero;

const Hero = require('./Hero');

class Warrior extends Hero {
    constructor(health) {
        super(health);
        this.rage = 0;
    }
    takeDamage(health) {
        this.rage += 1;
        super.takeDamage(health);
    }
}

module.exports = Warrior;

const Hero = require('./Hero');

class Warrior extends Hero {
    constructor(health) {
        super(health);
        this.rage = 0;
    }
    takeDamage(health) {
        this.rage += 1;
        super.takeDamage(health);
    }
}

module.exports = Warrior;

const Hero = require('./Hero');

class Warrior extends Hero {
    constructor(health) {
        super(health);
        this.rage = 0;
    }
    takeDamage(health) {
        this.rage += 1;
        super.takeDamage(health);
    }
}

module.exports = Warrior;

Để ý cái thứ 6 dưới đây sẽ có 2 code điền 2 bên nhé

const Hero = require('./Hero');

class Warrior extends Hero {
    constructor(health) {
        super(health);
        this.rage = 0;
    }
    takeDamage(health) {
        this.rage += 1;
        super.takeDamage(health);
    }
}

module.exports = Warrior;

class Hero {
    constructor(health) {
        this.health = health;
    }

    takeDamage(health) {
        this.health = this.health - health;
    }
}

module.exports = Hero;

end

function startsWithX(string) {
    let xstring = string.slice(0, 1);

    xstring = xstring.toLowerCase();
    if (xstring === "x") {
        return true;
    }
    else {
        return false;
    }
}

module.exports = startsWithX;

function startsWithX(string) {
    let xstring = string.slice(0, 1);

    xstring = xstring.toLowerCase();
    if (xstring === "x") {
        return true;
    }
    else {
        return false;
    }
}

module.exports = startsWithX;

function endsWithX(string) {
    let xstring = string.slice(-1);

    xstring = xstring.toLowerCase();
    if (xstring !== "x") {
        return false;
    }
    else {
        return true;
    }
}

module.exports = endsWithX;

function isAllX(string) {
    for (let i = 0; i < string.length; i++) {
        let xstring = string[i];
        xstring = xstring.toUpperCase();
        if (xstring !== "X") {
            return false;
        }
    }

    return true;
}

module.exports = isAllX;

function findFirstX(string) {
    for (let i = 0; i < string.length; i++) {
        let xstring = string[i];

        if (xstring === "x") {
            return i;
        }
    }
}

module.exports = findFirstX;

function splitAtX(string) {
    for (let i = 0; i < string.length; i++) {
        let xstring = string[i];

        if (xstring === "x") {
            xstring1 = string.slice(i + 1, string.length);
            xstring2 = string.slice(0, i);
            if (xstring1.length < xstring2.length) {
                return xstring2;
            }
            else {
                return xstring1;
            }
        }
    }
}

module.exports = splitAtX;

đáp án ARRAYS

const array = [1, 2, 3];// <-- create an array here!

module.exports = array;

function hasOne(array) {
    if (array.indexOf(1) === -1) {
        return false;
    }

    return true;
}

module.exports = hasOne;

function sumEven(array) {
    let s = 0;
    for (let i = 0; i < array.length; i++) {
        if (array[i] % 2 === 0) {
            s = s + array[i];
        }
    }

    return s;
}

module.exports = sumEven;

function unique(array) {
    let r = [];
    for (let i = 0; i < array.length; i++) {
        if (r.indexOf(array[i]) === -1) {
            r.push(array[i]);
        }
    }
    return r;
}

module.exports = unique;

function addOne(array) {
    for (let i = 0; i < array.length; i++) {
        array[i] = array[i] + 1;
    }
}

module.exports = addOne;

function removeOccurrences(array, num) {
    for (let i = array.indexOf(num); i !== -1; i = array.indexOf(num)) {
        array.splice(i, 1);
    }
}

module.exports = removeOccurrences;

đáp án OBJECTS

const order = {
    pizzas: 2,
    extraCheese: true,
    deliveryInstructions: "go to build"
};

module.exports = order;

function numberOfPizzas(order) {
    return order.pizzas;
}

module.exports = numberOfPizzas;

function numberOfPizzas(orders) {
    let s = 0;
    for (let i = 0; i < orders.length; i++) {
        s = s + orders[i].pizzas;
    }

    return s;
}

module.exports = numberOfPizzas;

const ORDER_TYPES = {
    PIZZA: 0,
    SALAD: 1,
    FRIES: 2
}

module.exports = ORDER_TYPES;

const ORDER_TYPES = require('./orderTypes');

function numberOfPizzas(orders) {
    let s = 0;

    for (let i = 0; i < orders.length; i++) {
        if (orders[i].type === ORDER_TYPES.PIZZA) {
            s = s + orders[i].pizzas;
        }
    }
    return s;
}

module.exports = numberOfPizzas;

function numberOfKeys(object) {
    let n = 0;
    for (let key in object) {
        n = n + 1;
    }

    return n;
}

module.exports = numberOfKeys;

function removeSecret(object) {
    delete object.secret
}

module.exports = removeSecret;

đáp án Practive Problems 2

function shortestString(str1, str2) {
    if (str1.length < str2.length) {
        return str1;
    } else {
        return str2;
    }
}

module.exports = shortestString;

function halfValue(numbers) {
    let retarr = [];

    for (let i = 0; i < numbers.length; i++) {
        if (0 === numbers[i] % 2) {
            retarr.push(numbers[i] / 2);
        } else {
            let tmp = Math.floor(numbers[i] / 2) + 1;
            retarr.push(tmp);
        }
    }

    return retarr;
}

module.exports = halfValue;

function countC(str) {
    let c = 0;
    let cstr = str.toLowerCase();
    let i = cstr.indexOf("c");

    while (-1 !== i) {
        c = c + 1;
        i = cstr.indexOf("c", i + 1);
    }

    return c;
}

module.exports = countC;

function countVowels(str) {
    let vowels = "aeiou";
    let c = 0;
    let vowelstr = str.toLowerCase();

    for (let i = 0; i < vowelstr.length; i++) {
        if (-1 !== vowels.indexOf(vowelstr[i])) {
            c = c + 1;
        }
    }

    return c;
}

module.exports = countVowels;

function reverse(string) {
    let retstr = "";
    for (let i = 0; i < string.length; i++) {
        retstr = string[i] + retstr;
    }

    return retstr;
}

module.exports = reverse;

function isPalindrome(string) {
    let i = 0;
    let endi = string.length - 1;
    while (endi >= i) {
        if (string[i] === string[endi]) {
            i = i + 1;
            endi = endi - 1;
        } else {
            return false;
        }
    }

    return true;
}

module.exports = isPalindrome;

function sumTogether(arr1, arr2) {
    let a = [];

    for (let i = 0; i < arr1.length; i++) {
        a[i] = arr1[i] + arr2[i];
    }

    return a;
}

module.exports = sumTogether;

function countElements(elements) {
    let countEle = {};

    for (let i = 0; i < elements.length; i++) {
        if (countEle.hasOwnProperty(elements[i])) {
            countEle[elements[i]] = countEle[elements[i]] + 1;
        } else {
            countEle[elements[i]] = 1;
        }
    }

    return countEle;
}

module.exports = countElements;

function playerHandScore(hand) {
    const jqkScore = { "J": 2, "Q": 3, "K": 4 };
    let s = 0;

    for (let i = 0; i < hand.length; i++) {
        s = s + jqkScore[hand[i]];
    }

    return s;
}

module.exports = playerHandScore;

đáp án LOGICAL OPERATORS

function willEat(hasPizza, hasDonuts, hasCookies) {
    if (hasPizza || hasDonuts || hasCookies) {
        return true;
    } else {
        return false;
    }
}

module.exports = willEat;

function double(x) {
    const def = x || "Undefined";

    if ("Undefined" === def) {
        return 0;
    } else {
        return x * 2;
    }
}

module.exports = double;

function canBreathe(isConnected, hasOxygen, aboveWater) {
    if (aboveWater) {
        return true;
    }
    if (isConnected && hasOxygen) {
        return true;
    }
    if (isConnected && aboveWater) {
        return true;
    }

    return false;
}

module.exports = canBreathe;

function friendName(friend) {
    if (friend) {
        if (typeof (friend.name) != "undefined") {
            return friend.name;
        }
    }
}

module.exports = friendName;

function carCrossing(aCrossing, bCrossing) {
    if (aCrossing) {
        if (bCrossing) {
            return false;
        } else {
            return true;
        }
    } else {
        if (bCrossing) {
            return true;
        } else {
            return false;
        }
    }
}

module.exports = carCrossing;

đáp án EXCEPTIONS

function throwError() {
    throw new Error("ee error !!.");
}

module.exports = throwError;

function catchError(fn) {
    try {
        fn();
    } catch (ex) {
        console.log(ex);
    }
}

module.exports = catchError;

function catchError(fn) {
    try {
        fn();
    } catch (ex) {
        return ex;
    }

    return false;
}

module.exports = catchError;

function startError() {
    let abc;

    abc.prop;
}

module.exports = startError;

đáp án TYPE CONVERSION

function toNumber(string) {
    let n = Number(string);
    if (isNaN(n)) {
        return 0;
    } else {
        return n;
    }
}

module.exports = toNumber;

function combineToString(a, b) {
    return String(a) + String(b);
}

module.exports = combineToString;

function isTruthy(a) {
    return Boolean(a);
}

module.exports = isTruthy;

function looseEquals(a, b) {
    return a == b;
}

module.exports = looseEquals;

function toJSON(obj) {
    return JSON.stringify(obj);
}

module.exports = toJSON;

const personJSON = `
    {
        "name": "jami",
        "age": 36,
        "isReal": false
    } 
`;

module.exports = personJSON;

những chỗ nào không có bảng code hiện ra thì mọi người cứ bấm next bỏ qua

khi có bảng code hiện ra thì mọi người chỉ cần nhìn cái tên như số 1 và copy đúng đoạn code ở các đáp án bên dưới để paste vào 2 và chạy run test là xong

1. đáp án intro to javascrit

const a = 3

module.exports = a;

như này là thành công và next sang bài tiếp theo

const a = 5;
const b = a;

module.exports = { a, b }

const a = false;
const b = true;

module.exports = { a, b }

const a = "World";
const b = "Hello World"

module.exports = { a,b }

let a = 3;

a = 5;

module.exports = a;

// all shoes are on sale this week!
const shoesCost = 49;

module.exports = shoesCost;

2.đáp án Functions and operators

function getMessage() {
    return "Hello World!";
}

module.exports = getMessage;

function addTwo(input) {
    return input + 2;
}

module.exports = addTwo;

function product(a,b) {
    return a * b;
}

module.exports = product;

function average(a, b, c, d) {
    return average = (a + b + c + d) / 4;
    
}

module.exports = average;

function getRandom() {
    return getRandom = Math.random();
}

module.exports = getRandom;

function getFloor(x) {
    return x = Math.floor(x);
}

module.exports = getFloor;

3. đáp án Conditionals

code bên dưới 

function isEqual(a, b) { return a === b; }

module.exports = isEqual;

function isNotEqual(a, b) {
    if (a !== b) {
        return true;
    }
    else {
        return false;
    }
}

module.exports = isNotEqual;

function isNotEqual(a, b) {
    if (a !== b) {
        return true;
    }
    else {
        return false;
    }
}

module.exports = isNotEqual;

function greater(first, last) {
    if (first > last) {
        return first;
    }
    else if (last > first) {
        return last;
    }
}

module.exports = greater;

function isEnough(cost, money) {
    return money >= cost;
}

module.exports = isEnough;

function canAccess(purchasedSubscription, freeTrial) {
    if (purchasedSubscription) {
        return true;
    } else if (freeTrial) {
        return true;
    } else {
        return false;
    }
}

module.exports = canAccess;

4. đáp án loops

function summation(n) {
    let s = 0;

    for (let i = 1; i <= n; i++) {
        s = s + i;
    }

    return s;
}

module.exports = summation;

function factorial(n) {
    let r = 1;
    for (let i = n; i >= 1; i--) {
        r = r * i;
    }

    return r;
}

module.exports = factorial;

function scream(n) {
    let s = "";
    for(let i = 1; i <= n; i++) {
        s += "a";
    }

    return s;
}

module.exports = scream;

function scream(n) {
    let returnStr = "";

    returnStr += "a";
    oddeven = n % 2;

    if (0 === oddeven) {
        for (let i = n - 1; i >= 1; i--) {
            oe = i % 2;

            if (oe === 0) {
                returnStr += "a";
            }
            else {
                returnStr += "A";
            }
        }
    }
    else {
        for (let i = n - 1; i >= 1; i--) {
            oe = i % 2;

            if (oe === 0) {
                returnStr += "A";
            }
            else {
                returnStr += "a";
            }
        }
    }

    return returnStr;
}

module.exports = scream;

function topDouble(value, top) {
    let val = value;
    let r = val;
    while (val < top) {
        r = val;
        val *= 2;
    }

    return r;
}

module.exports = topDouble;

5. đáp án Practice Problems 1 có 5 cái cứ bấm next là được

function isEven(num) {
    isE = num % 2;
    return isE === 0;
}

module.exports = isEven;

function smallerNumber(num1, num2) {
    if (num1 > num2) {
        return num2;
    }
    else {
        return num1;
    }
}

module.exports = smallerNumber;

const fakeName = require('./fakeName');

const message = `
    Hello, ${fakeName}! You left a package at the office today.
    You can pick up tomorrow at 10am, ${fakeName}. 
    If not I will drop it off this weekend.
    Goodbye ${fakeName}!
`;

module.exports = message;

function checkNumber(num) {
    if (num > 0) {
        return "positive";
    } else if (num === 0) {
        return "zero";
    } else {
        return "negative";
    }
}

module.exports = checkNumber;

function maxSum(num) {
    if (num < 0) {
        return 0;
    }

    let r = 0;
    for (let i = 1; i <= num; i++) {
        r += i;
    }

    return r;
}

module.exports = maxSum;

kết thúc phần 1 có thể bấm đây qua phần 2 của basic luôn - link

discord :

Discord - Group Chat That's All Fun & Games

Discord is great for playing games and chilling with friends, or even building a worldwide community. Customize your own space to talk, play, and hang out.

https://discord.com

It's finally here! Join our Crew3 and earn your spot in the $SNS DAO

➤ http://snsdomains.crew3.xyz

➤ New Quests added Daily! 10 people to Like/RT this tweet will also be selected for the Stork role - Winners selected below. #Sui isn't ready.

Let's get Acquainted! Meet the founder of the Sui Name Service in our 4th ever SNS blog post. This is a protocol by the people, for the people. Read more below: https://blog.sns.domains/meet-the-team-1-6097ebbdc204

xem ví mình dùng cái nào thì chọn - ví hold token thì chọn cái trên , ví chơi nft thì chọn cái dưới hoặc chọn cả 2 cũng đc

chọn cái nào muốn bảo vệ

đợi cho nó load xong và import token mạng eth hoặc nft nào mà mình muốn bảo vệ

add bn token hay nft tùy thích - sau đó chọn protect

tốn chút fee eth

như vậy là xong bước 1

tiếp theo chọn setup

nhập địa chỉ ví - tốn fee eth - nhập 1 địa chỉ ví khác ví đang dùng

tiếp theo đến bước 3

chọn mint FAU - tốn fee eth

BẤM protect faucet token - tốn fee eth

tiếp theo bấm begin live test - tốn fee eth

quay lại my dashboad xem có như ảnh dưới chưa đồng thời check ví

twitter: link

điền from : link

cần làm các bước như bên dưới để lấy public key và signature để điền form

bước 1 : tải file này về - tải xong thì nên ném vào ổ D làm cho dễ k ở trong thư mục nào ( đường link nó chỉ là D:\ hoặc C:\ ) cái này dành cho những ai k quen dùng - còn ai quen dùng các bước bên dưới thì để đâu cũng được

bước 2 : bấm window + R rùi gõ powershell để mở windows powershell

bước 3 : rùi đến ổ mà lưu file vừa tải về

khi mở powershell thì nó mặc định ở ổ C nhé - nếu để file ở ổ C thì k cần di chuyển

còn ai để ở ổ D hay F thì nhập D: rùi bấm enter

bước 4 : copy đoạn bên dưới nhập vào sau bấm enter

./manta-trusted-setup-x86_64-pc-windows-msvc register

sau đó nó hiện ra chỗ để mình đăng ký nhập twitter và gmail

sau đó nó cho public key và mấy dòng dưới - copy điền vào form bên trên và cũng lưu lại chỗ nào đó sau này cần

khi điền form đến cuối thì nó bảo điền ví mạng Calamari để sau nhận NFT nhé

cách lấy địa chỉ ví Calamari đầu là d…… nhé

link hoặc ai dùng quen bên ví polkadot này rùi thì cứ vào mấy ví nhập tên mạng calamari là ra

theo dõi twitter dự án

nhiệm vụ gồm 2 phần :

1. GAIA - là phần bắt buộc nhé

2. Harvest - dành cho những ai có vốn dư giả và săn retro

phần 1 : đối với GAIA làm như bên dưới

vào trang web

liên kết ví

sau đó bấm next

bấm đến lúc nào ra như này là xong

phần 2 : đối với những ai tham gia Harvest thì xem bên dưới nhé ( mất tiền và không khuyến thích tham gia vì cũng chưa chắc đã retro - nếu có token mạng nào trúng kèo và dán vào nó hiện mà giá bán tương đương trên các trang web khác thì có thể giao dịch lấy tương tác )

vào trang web và liên kết ví

đợi nó đồng bộ tất cả các giao dịch từ 21-11-2020 đến nay nhé - ai nhiều giao dịch thì khá là lâu có thể mất tận 1 ngày nhé

đăng ký xong cứ treo nó ở đó - đến bước tiếp theo vào mục swap và swap hoặc bridge qua các mạng khác nhau ( có thể mất nhiều fee nhé )

lưu ý :

1. ưu tiên swap các mạng có fee rẻ như matic , op , arbitrum ( arbitrum sau có thể có air tương tác mạng )

2. swap thì tùy theo lượng vốn của mỗi người mà căn lượng vol giao dịch nhé

3. có thể 1 tuần swap 1 2 lần hoặc 1 tháng swap 1 2 lần ( qua 2 3 mạng j đó )

4. còn đối với bridge thì nên bridge qua 2 - 3 mạng

sau đó đến trang tiện ích mở rộng chrome://extensions chọn chế độ dành cho nhà phát triển và úp file vừa giải nén lên

B2: Tạo ví và lưu lại backup ví cẩn thận - vì khoảng 1 năm nữa mới ra token mà mất key ví thì coi như xong

B3 : faucet BNB test và TNLK test

BNB test : link

TNLK test : link

B5 : bắt đầu test

vào discover và chọn upload file và tải 1 file bất kì nên

sau khi xong vào trang cá nhân xem file đã được update lên chưa

quay lại discover và chọn 1 ảnh của 1 người bất kì ( hoặc có thể tương tác chéo với mấy người trong nhóm để họ đồng ý ) sau đó bấm request the file -→ chọn số ngày -→ và xác nhận -→ đợi người ta xác nhận đồng ý cho mình tải file đó về

Nếu chủ hồ sơ không duyệt hồ sơ, người nộp hồ sơ sẽ luôn hiển thị trạng thái “chờ xử lý”

Sau khi chủ sở hữu dữ liệu hoàn tất việc phê duyệt, người đăng ký có thể vào trang chi tiết này và tải xuống tệp

B6 : cách xác nhận của người khác khi nhận được yêu cầu tải file của mình xuống

vào incoming requets và chọn review request

chọn yes hoặc no và xác nhận

B6 : điền form khi có vấn đề : link - k có lỗi cũng điền form cho có tương tác

đặc biệt sự kiện hàng tuần

mỗi tuần top 10 người share được file mà có tổng thời gian nhiều nhất sẽ chia 10k NLK

top 1-5 nhận 1k5 NLK và top 6 -10 nhận 500 NLK

giải thích cơ chế : thời gian file là thời gian mà người khác đã muốn mình chia sẻ file cho họ

ví dụ : người ta yêu cầu mình chia sẻ file cho 1 ngày thì khi mình xác nhận thì thời gian mình nhận được là 1 ngày

ZKsync Bridge | Transfer funds between ZKsync and Ethereum

With the ZKsync Bridge you can easily deposit tokens to ZKsync. Enjoy faster, cheaper and more efficient transactions with the future proof zkEVM scaling Ethereum's security and values.

https://portal.zksync.io

vào trang web test

https://testnet.switch.mute.io/

bấm vào swap và chọn cặp để swap

bấm vào pool để thêm thanh khoản

add lq xong rùi rút

discord :

Discord - Group Chat That's All Fun & Games

Discord is great for playing games and chilling with friends, or even building a worldwide community. Customize your own space to talk, play, and hang out.

https://discord.com

link testnet :

https://play.zkasino.io/

bước 1 : kết nối ví chọn mạng zksync alpha testnet

bước 2 : bấm request & tweet -→ đăng bài lên twitter

bước 3 : mint token test

bước 4 : chơi game có 7 trò

bước 5 chơi xong vào discord feaback lỗi các thứ