Please enable JavaScript.

Coggle requires JavaScript to display documents.

Mastering Ethereum (Chapter 6: Transactions (List of Chain ID's (1 …

- - - - geth console
        geth attach
        geth console 2>> /dev/null
        geth --verbosity 0 console
  - - - nonce, gasPrice, gasLimit, to, value, data, chainID, 0, 0
    - - K_1 = r^{-1} (sR - zG)
      - K_2 = r^{-1} (sR' - zG)
- - - - The main public Ethereum blockchain. Real ETH, real value, and real consequences.
    - - Ethereum public test blockchain and network. ETH on this network has no value.
    - - Ethereum public test blockchain and network using the Aura consensus protocol with proof of authority (federated signing). ETH on this network has no value. The Kovan test network is supported by Parity only. Other Ethereum clients use the Clique consensus protocol, which was proposed later, for proof of authority–based verification.
    - - Ethereum public test blockchain and network, using the Clique consensus protocol with proof of authority (federated signing). ETH on this network has no value.
    - - Connects to a node running on the same computer as the browser. The node can be part of any public blockchain (main or testnet), or a private testnet.
    - - Allows you to connect MetaMask to any node with a Geth-compatible Remote Procedure Call (RPC) interface. The node can be part of any public or private blockchain.
  - - - Just the normal account that you have private key control (e.g. MetaMask)
    - - The working details (First connect to your EOA, and then send the contract to the network with some gas fee to the zero address)
      - All the transfer based on code are in the internal transaction tab
- - - - :red_flag: Read more about ERC!
      - Necessary Functions to Implement
        totalSupply
        balanceOf
        transfer
        transferFrom (used in combination with approve)
        approve
        allowance
        Transfer (Event)
        Approval (Event)
      - Optional Functions
        name (e.g. "US Dollars")
        symbol (e.g. "USD")
        decimals
      - Data Structures
        
        Data Mapping
        
        Track balances
        
        Track Allowances
    - - Adding tokenFallback function
        
        If the destination of a transfer is a contract and the contract does not have support for tokens (i.e., does not implement tokenFallback), the transfer fails.
    - - ERC20-compatible interface
      - Transfer token using send
      - Compatible with ERC820 for token contract registration
      - To allow contracts and addresses to control which tokens they send through a tokensToSend function that is called prior to sending
      - Operating the same way, whether sending to a contract or EOA.
      - Minting and burning of tokens possible
      - To enable operators (trusted third parties, intended to be verified contracts) to move tokens on behalf of a token holder.
      - To provide meta data on token transfer transactions in userData and operatorData fields
    - - Can be positive (painting) or negative (load) records
      - Using mapping (uint256 => address) private deedOwner; to track the ownership.
    - - Using standard can help your token's interoperability
      - Using existing tested secure implementation can prevent unnecessary security issues.
      - You can always extend your token standard, but beware of all the security issues!! (no a small list...)
        
        Owner control
        
        blacklisting
        
        whitelisting
        
        minting
        
        recovery
        
        Burning
        
        Minting
        
        Crowdfunding
        
        Caps
        
        The opposite of the "minting" feature
        
        Recovery backdoors
        
        Whitelisting
        
        Blacklisting
  - - - The private key is the ownership and there is no intermediary to hold anything about that ownership for you.
      - This can disrupt the ordinary extrinsic things such as real estate, corporate voting shares, trademarks, and gold bars hold by the governments, etc.
      - E.g. or moving corporation (extrinsic) to an equity or voting token in a DAO or similar (intrinsic organization.
  - - - Rental car
      - Discussion forum
      - An exclusinve website
      - Hotel room
        
        Tokenization of hotel resources?
        
        What are the pain points in hotel
    - - Gold
      - real estate
      - car
      - oil
      - energy
      - MMOG items
    - - Shareholder equity in (DAO)
      - Legal entity (Corporation)
    - - CryptoPunks
      - A painting
    - - Avatar
      - National ID (legal identity)
    - - Decentralized reputation system
        
        Marriage record
        
        Birth certificate
        
        College degree
    - - Access or pay for a service
    - - Derivative market: get rid off the custodian between the buyer and seller
      - Mainly good for the Non-Deliverable Forward (NDF) or Cash Settled Forward (CSF)
  - - - So you can have a platform that help the customers to easily use any kind of token in just on platform (help the utility token builders to build a platform like OS?)
  - - - Consensys EIP 20
      - OpenZeppelin StandardToken
- - - - Node.js
        
        Golang
        
        JavaScript
        
        Python
  - - - Solution: Hardened Child Key Derivation: using the parent private key to derive the child public keys.
        
        The index i' means 2^31 + i as the hardened child address
  - - - Using pass phrase for the ETH wallet with be included into the KDF (Key Derivation Function) and hashed for 262,144 times to prevent brute force attack.
  - - - Mnemonic code words, based on BIP-39
        
        All words are created randomly and presented to user after generated. (normally 12-24 words based on 128-256 bits of entropy
        
        1. Generating Mnemonic Words
        
        Create a cryptographically random sequence S of 128 to 256 bits.
        
        Create a checksum of S by taking the first length-of-S ÷ 32 bits of the SHA-256 hash of S.
        
        Add the checksum to the end of the random sequence S.
        
        Divide the sequence-and-checksum concatenation into sections of 11 bits.
        
        Map each 11-bit value to a word from the predefined dictionary of 2,048 words.
        
        Create the mnemonic code from the sequence of words, maintaining the order.
        
        2. From Mnemonic To Seed
        
        The first parameter to the PBKDF2 key-stretching function is the mnemonic produced in step 6.
        
        The second parameter to the PBKDF2 key-stretching function is a salt. The salt is composed of the string constant "mnemonic" concatenated with an optional user-supplied passphrase.
        
        PBKDF2 stretches the mnemonic and salt parameters using 2,048 rounds of hashing with the HMAC-SHA512 algorithm, producing a 512-bit value as its final output. That 512-bit value is the seed.
        
        Pass phrase must always used cautiously, because not backing up properly might cause lost of found if the pass phrase holder lost the ability to enter the pass phrase.
      - HD wallets, based on BIP-32
      - Multipurpose HD wallet structure, based on BIP-43
      - Multicurrency and multiaccount wallets, based on BIP-44
      - Mnemonic Code Convertor
      - Given x on an EC how to find y?
        
        sqrt(x^3 + ax + b) or -sqrt(x^3 + ax + b)
    - - m/purpose'/coin-type'/account'/change/address_index
- - - - More centralized and relies on the trusted third party tool boxes: e.g. IBM SGX, TLSNotory Proof, etc.
    - - On chain data aggregation systems
- - - - A peer-to-peer (P2P) network connecting participants and propagating transactions and blocks of verified transactions, based on a standardized “gossip” protocol
      - Messages, in the form of transactions, representing state transitions
      - A set of consensus rules, governing what constitutes a transaction and what makes for a valid state transition
      - A state machine that processes transactions according to the consensus rules
      - A chain of cryptographically secured blocks that acts as a journal of all the verified and accepted state transitions
      - A consensus algorithm that decentralizes control over the blockchain, by forcing participants to cooperate in the enforcement of the consensus rules
      - A game-theoretically sound incentivization scheme (e.g., proof-of-work costs plus block rewards) to economically secure the state machine in an open environment
      - One or more open source software implementations of the above (“clients”)
    - - P2P network
        
        Ethereum runs on the Ethereum main network, which is addressable on TCP port 30303, and runs a protocol called ÐΞVp2p.
      - Consensus rules
        
        Ethereum’s consensus rules are defined in the reference specification, the Yellow Paper (see “Further Reading”).
      - Transactions
        
        Ethereum transactions are network messages that include (among other things) a sender, recipient, value, and data payload.
      - State machine
        
        Ethereum state transitions are processed by the Ethereum Virtual Machine (EVM), a stack-based virtual machine that executes bytecode (machine-language instructions). EVM programs, called “smart contracts,” are written in high-level languages (e.g., Solidity) and compiled to bytecode for execution on the EVM.
      - Data structures
        
        Ethereum’s state is stored locally on each node as a database (usually Google’s LevelDB), which contains the transactions and system state in a serialized hashed data structure called a Merkle Patricia Tree.
      - Consensus algorithm
        
        Ethereum uses Bitcoin’s consensus model, Nakamoto Consensus, which uses sequential single-signature blocks, weighted in importance by PoW to determine the longest chain and therefore the current state. However, there are plans to move to a PoS weighted voting system, codenamed Casper, in the near future.
      - Economic security
        
        Ethereum currently uses a PoW algorithm called Ethash, but this will eventually be dropped with the move to PoS at some point in the future.
      - Clients
        
        Ethereum has several interoperable implementations of the client software, the most prominent of which are Go-Ethereum (Geth) and Parity.
  - - - Frontier—The initial stage of Ethereum, lasting from July 30, 2015, to March 2016.
    - - Ice Age—A hard fork to introduce an exponential difficulty increase, to motivate a transition to PoS when ready.
    - - Homestead—The second stage of Ethereum, launched in March 2016.
    - - DAO—A hard fork that reimbursed victims of the hacked DAO contract and caused Ethereum and Ethereum Classic to split into two competing systems.
    - - Tangerine Whistle—A hard fork to change the gas calculation for certain I/O-heavy operations and to clear the accumulated state from a denial-of-service (DoS) attack that exploited the low gas cost of those operations.
    - - Spurious Dragon—A hard fork to address more DoS attack vectors, and another state clearing. Also, a replay attack protection mechanism.
    - - Metropolis Byzantium—Metropolis is the third stage of Ethereum, current at the time of writing this book, launched in October 2017. Byzantium is the first of two ha
- - - - A functional (declarative) programming language, with Lisp-like syntax. It was the first high-level language for Ethereum smart contracts but is rarely used today.
    - - A procedural (imperative) programming language with a syntax similar to Python. Can also be used to write functional (declarative) code, though it is not entirely free of side effects.
    - - A procedural (imperative) programming language with a syntax similar to JavaScript, C++, or Java. The most popular and frequently used language for Ethereum smart contracts.
    - - A more recently developed language, similar to Serpent and again with Python-like syntax. Intended to get closer to a pure-functional Python-like language than Serpent, but not to replace Serpent.
    - - A newly developed language, influenced by Erlang, with explicit state transitions and without iterative flows (loops). Intended to reduce side effects and increase auditability. Very new and yet to be widely adopted.
  - - - Before you public your SC, you can have a function called SELFDESTRUCT or called SUICIDE before, which is not a good word and thus people switched to the current function name.
        Once you called that function, the SC will be destroyed with all a negative gas fee for refunding, which is an incentive mechanism to let developers to save the space on EVM network.
        But all the transaction history will still be on the ETH network blockchain.
        If the SC doesn't has the SELFDESTRUCT function, then this SC cannot be deleted.
        
        selfdestruct(address recipient);
    - - A Smart Contract is a script that is immutable and deterministic and is deployed on the Ethereum Virtual Machine as part of the ETH network protocol (i.e. on the decentralized ETH world Computer)
  - - - Built-in
        
        addmod
        
        mulmod
        
        keccak256, sha256, sha3, ripemd160
        
        ecrecover
        
        selfdestruct(recipient_address)
        
        this
      - function FunctionName([parameters]) {public|private|internal|external} [pure|constant|view|payable] [modifiers] [returns (return types)]
    - - Global Variables/Objects
        
        block
        
        block.blockhash(blockNumber)
        
        block.coinbase
        
        block.difficulty
        
        block.gaslimit
        
        block.number
        
        block.timestamp
        
        msg
        
        msg.value
        
        msg.sender
        
        msg.sig
        
        msg.gas
        
        tx
        
        tx.gasprice
        
        tx.origin
        
        address
        
        address.transfer(amount)
        
        address.balance
        
        address.send(amount)
        
        address.call(payload)
        
        address.callcode(payload)
        
        address.delegatecall()
      - Variable types
        
        Boolean (bool)
        Integer (uint, int) to 256 bits
        Fixed point (fixed, ufixed)
        Address (this is obj)
        Byte array (fixed, byte1 to byte32)
        Byte array (dynamic, bytes or string)
        Enum (NAME {LABLE1 ... LABEL2})
        Arrays (either fixed or dynamic: int32[][]5])
        Struct (struct NAME {TYPE1 VAR1; TYPE2 Var2; ...})
        Mapping (Key value pairs: mapping(KEY_TYPE => VALUE_TYPE))
    - - interface
      - library
    - - Time units
        
        seconds, minutes, hours, days
      - Ether units
        
        wei, finney, szabo, ether
      - uint is the same as declears as uint256
- - - - A convert function for explicit type casting
    - - Conditions
      - Effects
      - Interaction
    - - public
      - private
      - constant
      - payable
    - - Compiling your .vy smart contract into LLL, bytecode or ABI format
    - - Vyper has built-in overflow protection, implemented in a two-pronged approach.
- - - - A:
    - - Used for signing the Tx and verifying identity
    - - ETH Address
        
        Hash the public key with KECCA256, and then get the last 20 bytes.
        
        Could have some other various verification methods.
- - - - Ethereum Casper (Proof of Stake)
      - History of Casper, Part 1
      - History of Casper, Part 2
      - History of Casper, Part 3
      - History of Casper, Part 4
      - History of Casper, Part 5
- - - - Use the built-in transfer function
      - Ensure that all logic that changes state variables happens before ether is sent out of the contract (or any external call)
      - Add a mutex
    - - Use secure Math library, and not the standard math operations
        
        OpenZeppelin can find many secure libraries (SafeMath library)
    - - Self-destruct/suicide
        
        Prevention: Create a new variable, such as depositedEther, as the track of the known ether deposited, and not the this.balance
      - Pre-sent ether
    - - Using the library keyword to build stateless and non-self-destructable library
    - - Always specify the visibility of all functions in a contract, even if they are intentionally public.
    - - Use the new keyword
      - Hard code external contract address
    - - Validate inputs
- - - - We normally have public parameters pre generated because finding the number of points on a EC is time consuming. Thus we already agree on: G=(A, B, p), q, g)). But in the ECDSA we still use mostly the discrete log like manipulation.
    - - What is EC?
        
        Elliptic Curve is a group that contains points what is defined as y^2 = x^3 + Ax + b (mod p), where p is a prime number. Here we first define a value q, and then list all the LHS and RHS points, then find the matched points.
      - How to define a EC?
        
        INPUTS
        
        Security parameter 1^n ...
        
        Conditions:
        A, B \in Z_p
        4A^3 + 27B^2 \neq 0 \mod p
        choose g \in E(Z_p) \ {O}
        
        OUTPUTS
        
        {G = (A, B, p), q, g}
        G is the EC Group
        A, B are the coef
        p is the modulo
        q is the size of the EC group
        g is the reference point or the point of origin, which can be any point on the EC group Z_q
      - How to use EC for Encryption and Signature?
        
        The Elliptic Curve Diffie–Hellman (ECDH) key agreement scheme is based on the Diffie–Hellman scheme,
        
        The Elliptic Curve Integrated Encryption Scheme (ECIES), also known as Elliptic Curve Augmented Encryption Scheme or simply the Elliptic Curve Encryption Scheme,
        
        The Elliptic Curve Digital Signature Algorithm (ECDSA) is based on the Digital Signature Algorithm,
        
        The deformation scheme using Harrison's p-adic Manhattan metric,
        
        The Edwards-curve Digital Signature Algorithm (EdDSA) is based on Schnorr signature and uses twisted Edwards curves,
        
        The ECMQV key agreement scheme is based on the MQV key agreement scheme,
        
        The ECQV implicit certificate scheme.
        
        NSA Suit B exclusively uses ECDSA & ECDH for digital signatures and key exchanges
        
        ECIES
      - What are the caveats?
        
        Don't implement by yours self and must make sure that the value of p is proper.
        
        The good source of randomness (entropy) is necessary, and even more important than that in the traditional RSA encryption.
      - Key parameters for security?
        
        For elliptic-curve-based protocols, it is assumed that finding the discrete logarithm of a random elliptic curve element with respect to a publicly known base point is infeasible: this is the "elliptic curve discrete logarithm problem" (ECDLP). The security of elliptic curve cryptography depends on the ability to compute a point multiplication and the inability to compute the multiplicand given the original and product points. The size of the elliptic curve determines the difficulty of the problem.
      - Is it quantum resistent? If not, how to solve the issues?
        
        No, because the discrete logarithm is easily solved by Shor's Algorithm
        
        Great source of learning Post Quantum Cryptography
      - How to plot an EC over the finite field?
        
        A demo
        
        Basically the idea is just to find all the points on E(Z_q) and not the real domain curve.
        The can be easily achieved by the algorithms shown in the S.O. answer (which is also what I described below)
      - Great explain and visualization
      - Who are the inventors and in what time?
        
        The use of elliptic curves in cryptography was suggested independently by Neal Koblitz[6] and Victor S. Miller[7] in 1985. Elliptic curve cryptography algorithms entered wide use in 2004 to 2005.
        
        Professor Neal Koblitz is in the Math department of UW... his overview to elliptic curve
      - Side notes
        
        Suite B's components are:
        
        Advanced Encryption Standard (AES) with key sizes of 128 and 256 bits. For traffic flow, AES should be used with either the Counter Mode (CTR) for low bandwidth traffic or the Galois/Counter Mode (GCM) mode of operation for high bandwidth traffic (see Block cipher modes of operation) – symmetric encryption
        
        Elliptic Curve Digital Signature Algorithm (ECDSA) – digital signatures
        
        Elliptic Curve Diffie–Hellman (ECDH) – key agreement
        
        Secure Hash Algorithm 2 (SHA-256 and SHA-384) – message digest
      - Counting the number of points in a curve (Using Schoof–Elkies–Atkin algorithm)
        
        Select a random curve and use a general point-counting algorithm, for example, Schoof's algorithm or Schoof–Elkies–Atkin algorithm,
        
        Select a random curve from a family which allows easy calculation of the number of points (e.g., Koblitz curves), or
        
        Select the number of points and generate a curve with this number of points using complex multiplication technique.[10]
      - What is the recommanded Key size?
        
        Normally the size of the underlying finite field should be double the size of the security parameter: for 128-bit of security we will need to have q = 256 for F_q.
      - How to find a point on EC given the curve y^2 = f(x) mod p?
        
        You just randomly try in the bound of p.
        
        By the Hasse bound
        
        p + 1 - 2 * sqrt(p) <= |E(Z_p)| <= p + 1 + 2 * sqrt(p)
      - How to add two points x_1, x_2?
        
        If x_1 \neq x_2, then P_1 + P_2 = (x_3, y_3) with
        
        x_3 = [m^2 - x_1 - x_2 mod p]
        and y_3 = [m (x_1 - x_3) - y_1 mod p],
        where m = [(y_2 - y_1)/(x_2 - x_1) mod p]
        
        if x1 = x2 but y1 \neq y2 then P1 = -P2 and so P1 + P2 = O
        
        If P1 = P2 and y1 = 0 then P1 + P2 = 2P1 = O
        
        if P1 = P2 and y1 \neq 0 then P1 + P2 = 2 P1 = (x_3, y_3) with
        
        x3 = [m^2 - 2x1 mod p] and
        y3 = [m(x1 - x3) - y1 mod p]
        where m = [(3x^2 + A) / (2y1)] mod p]
    - - The key is in the Step 9: Trapdoor function
        
        :red_flag: The basis of security of the ECDSA is that we don't have the reverse operation for addition in EC, i.e. give R and S in R = k * S we have no way to find the value of k (for even one step of addition). That is because when we reflect and find a point form the current point, we have no idea where does the line come from... And we will do millions of such operation, which means that it is impossible to reverse the equation and find k.
      - Step 10: Generating the public and private key
        
        :red_flag: In ECDSA the relationship between a public key and a private key is like this: pk = g * sk. Where sk is a random number, and pk is a point on the EC after multiplying g (the reference point that is also on the EC) by the sk.
- - - - Efficient if p-1 has only small prime factors
    - - O(sqrt(q) * polylog(q)) with constant memory
      - O(N^{1/4} * polylog(N))
    - - Sub-exponential run time
        
        General number field sieve: 2^{O(logN)^1/3 * (log log N)^2/3}
  - - - Usage: when the group order q is not prime and the factorization of q is known, or easy to determine >> reduce to the problem of DL for the prime-order subgroups of G
    - - O(sqrt(q) * polylog(q)), storing O(sqrt(q)) group elements.
  - - - RSA: 3072 bits modulus length
      - Order-q Subgroup of Z*_p: p: 3072, q: 256
      - EC Group Order q: 256 bits
    - - EC Group Order q: 512 bits
      - RSA Modulus Length: 15360 bits
      - Order-q Subgroup of Z*_p: p: 15360, q: 512
- - - - Can be used for efficiently give one time signature signning