NFT App

If you’re an aspiring artist or just someone who wants to use a new Ethereum application, app.rarible.com is a great place to start. The user interface is easy to use and understand. Rarible allows anyone to mint, buy, or sell an Ethereum Non-Fungible Token (NFT). All you need to use is a web3 enabled wallet app like Coinbase Wallet App or Metamask so your Ethereum address can hook in to the website. If you don’t exactly know what Non Fungible means, think about something that is rare or unique. It has specific metadata that sets it apart from other NFTs which makes it perfect for art or digital collectibles. A potential use case is for in-game digital items like Fortnite skins or username/password login crudentials. If you want to see the NFT I put up for sale on Rarible use this link.

Uniswap Token Governance

Now that the Uniswap Airdrop has died down, even though eligible addresses are still claiming UNI everyday, the Ethereum network is finally cheaper to use. Gas prices are below 100 gwei when they were as high as 800 the night of the airdrop. That means it is now 8x cheaper to do anything on the Ethereum blockchain. While the airdrop is cooling down, governance discussions for Uniswap are heating up. There is one proposal that many Ethereans are hopeful will come to vote and pass. The proposal involves addresses which had interacted with Uniswap contracts in one way or another but were not eligible for the UNI airdrop. When the Uniswap team designed the retroactive airdrop of UNI tokens to previous users and liquidity providers, they may have forgotten how some users interact with Uniswap through a string of calls rather than directly with the Uniswap V1 or V2 contracts/routers. This left users from Dharma, Argent, Matcha, and several others out of luck when it came time to claim their tokens. Luckily for those users, governance is now in the hands of the community and Nadav from Dharma has done a wonderful job creating discussion, proposal, and course of action for how to reward these users. It will come down to a community proposal and vote around October 17th and if this proposal passes 20k+ additional users will have a chance to claim their reward. Anyone who holds a non-zero amount of $UNI can vote in either direction of this proposal when the time comes. Users can do this by going to app.uniswap.org/#/vote, connecting their Ethereum wallet that holds $UNI tokens, and delegating the votes using the button provided. At this point in time, Andre Cronje has over 14 million $UNI tokens delegated to him for voting purposes. To get a proposal into the voting system, an indivdiual/team needs to maintain 10 million $UNI. Then to get the vote to pass, an individual/team needs 40 million $UNI to hold quorum. Since there are less than 100 million $UNI circulating right now, attaining 40 million $UNI for a vote may be a tough feat to reach.

• Discussion/Proposal

• Application

• Github

Market Update (Monday 9:30 AM ET)

Percent Change (Rounded) Based on Last Monday Open (9:30 AM ET)

Bitcoin- $10,930 (+4%)

Ether- $364 (+7%)

Gold- $1,870 (-1%)

DJI Average- 27,362 (UNCH)

NYSE Composite Index- 12,650 (UNCH)

NASDAQ Composite Index- 11,084 (+4%)

S&P500 Index- 3,333 (+3%)

New Developments

1. Federally Chartered Banks & Thrifts approved for stablecoin activities, OCC

2. tBTC has relaunched on Ethereum, Keep Network

3. State of EIP1559, Tim Beiko

4. ConsenSys wins Hong Kong Central Bank Digital Currency project, The Block

5. Synthetix, Uniswap, Chainlink to test Optimism’s Layer 2 scaling solution

6. Uniswap Governance trying to airdrop to users of Apps and Proxy Contracts

7. Kucoin hacked for at least $150 million in crypto, some dumped using Uniswap

8. Why Automated Market Makers (AMMS) are interesting for non-crypto audience, Cuy Sheffield- Head of Crypto @ Visa

   Cuy Sheffield @cuysheffield 1/ Here's my rough attempt at explaining why automated market makers (AMMs) are interesting to a non-crypto audience h/t @HendoVentures

   September 27th 2020

   5 Retweets25 Likes

Industry Insights

• What is Impermanent Loss? DeFi 101

• 5 Questions with Tarun Chitra, Blue Kirby

• Uniswap v3 will be here sooner than many think, Jason Smith

• Ethereum and the Gartner Hype Cycle, Anthony Bertolino

• Escaping the Dark Forest, samczsun

• Create NFT using Rari App, Bryan Divisions

• Why NFTs are Valuable, Adam Cochran

  Adam Cochran @AdamScochran 1/8 Those who don’t yet understand the value of NFT art, fail to understand the concept of ‘haecceity’ - the non-physical characteristics of an item within a class that make that item unique.

  September 21st 2020

  16 Retweets40 Likes

For Developers

1. How to code up your own ERC721 (NFT), Dapp University

2. DeFi Wiki by Dharma

3. Coinbase’s Rosetta Specification: New Coin Additions

4. Track Historical Compound Lend/Borrow Rates, Matt Solomon

5. Play a game to learn smart contract language Vyper

6. Want to make a name for yourself in the Ethereum Community?

   Sam Richards @samonchain Are you a developer wondering how to make a name for yourself in the @ethereum community? Write some content for @ethdotorg! Here are some open requests for new pages: github.com/ethereum/ether…We also welcome new ideas - open a new issue & sprinkle it with your knowledge! ✨🧙‍♂️ethereum/ethereum-org-websiteEthereum.org is a primary online resource for the Ethereum community. - ethereum/ethereum-org-websitegithub.com

   September 25th 2020

   17 Retweets51 Likes

Blockchain Activity

Create an Ethereum based voting smart contract:

*Tools: Metamask (Wallet), Remix IDE (Development Environment), Solidity (Smart Contract Language) Ethereum (Blockchain)

# set pragma

pragma solidity ^0.4.22;

# contract (Source)

contract Ballot {
    // This declares a new complex type which will
    // be used for variables later.
    // It will represent a single voter.
    struct Voter {
        uint weight; // weight is accumulated by delegation
        bool voted;  // if true, that person already voted
        address delegate; // person delegated to
        uint vote;   // index of the voted proposal
    }

    // This is a type for a single proposal.
    struct Proposal {
        bytes32 name;   // short name (up to 32 bytes)
        uint voteCount; // number of accumulated votes
    }

    address public chairperson;

    // This declares a state variable that
    // stores a `Voter` struct for each possible address.
    mapping(address => Voter) public voters;

    // A dynamically-sized array of `Proposal` structs.
    Proposal[] public proposals;
    
    constructor(bytes32[] proposalNames) public {
        chairperson = msg.sender;
        voters[chairperson].weight = 1;

        // For each of the provided proposal names,
        // create a new proposal object and add it
        // to the end of the array.
        for (uint i = 0; i < proposalNames.length; i++) {
            // `Proposal({...})` creates a temporary
            // Proposal object and `proposals.push(...)`
            // appends it to the end of `proposals`.
            proposals.push(Proposal({
                name: proposalNames[i],
                voteCount: 0
            }));
        }
    }

    // Give `voter` the right to vote on this ballot.
    // May only be called by `chairperson`.
    function giveRightToVote(address voter) public {
        // If the first argument of `require` evaluates
        // to `false`, execution terminates and all
        // changes to the state and to Ether balances
        // are reverted.
        // This used to consume all gas in old EVM versions, but
        // not anymore.
        // It is often a good idea to use `require` to check if
        // functions are called correctly.
        // As a second argument, you can also provide an
        // explanation about what went wrong.
        require(
            msg.sender == chairperson,
            "Only chairperson can give right to vote."
        );
        require(
            !voters[voter].voted,
            "The voter already voted."
        );
        require(voters[voter].weight == 0);
        voters[voter].weight = 1;
    }

    function delegate(address to) public {
        // assigns reference
        Voter storage sender = voters[msg.sender];
        require(!sender.voted, "You already voted.");

        require(to != msg.sender, "Self-delegation is disallowed.");

        // Forward the delegation as long as
        // `to` also delegated.
        // In general, such loops are very dangerous,
        // because if they run too long, they might
        // need more gas than is available in a block.
        // In this case, the delegation will not be executed,
        // but in other situations, such loops might
        // cause a contract to get "stuck" completely.
        while (voters[to].delegate != address(0)) {
            to = voters[to].delegate;

            // We found a loop in the delegation, not allowed.
            require(to != msg.sender, "Found loop in delegation.");
        }

        // Since `sender` is a reference, this
        // modifies `voters[msg.sender].voted`
        sender.voted = true;
        sender.delegate = to;
        Voter storage delegate_ = voters[to];
        if (delegate_.voted) {
            // If the delegate already voted,
            // directly add to the number of votes
            proposals[delegate_.vote].voteCount += sender.weight;
        } else {
            // If the delegate did not vote yet,
            // add to her weight.
            delegate_.weight += sender.weight;
        }
    }

    function vote(uint proposal) public {
        Voter storage sender = voters[msg.sender];
        require(!sender.voted, "Already voted.");
        sender.voted = true;
        sender.vote = proposal;

        // If `proposal` is out of the range of the array,
        // this will throw automatically and revert all
        // changes.
        proposals[proposal].voteCount += sender.weight;
    }

    function winningProposal() public view
            returns (uint winningProposal_)
    {
        uint winningVoteCount = 0;
        for (uint p = 0; p < proposals.length; p++) {
            if (proposals[p].voteCount > winningVoteCount) {
                winningVoteCount = proposals[p].voteCount;
                winningProposal_ = p;
            }
        }
    }

    // Calls winningProposal() function to get the index
    // of the winner contained in the proposals array and then
    // returns the name of the winner
    function winnerName() public view
            returns (bytes32 winnerName_)
    {
        winnerName_ = proposals[winningProposal()].name;
    }
}

Earn Opportunity

Create and list an NFT using Rarible app. Anyone with Ether and an Ethereum wallet can create one using a real world piece of art or digital representation of art. Here is a tutorial on how to do so.