Please enable JavaScript.

Coggle requires JavaScript to display documents.

Hyperledger Fabric & SQL*PLUS [Access Control Comparison] (Hyperledger…

- - - - Networks need to be permissioned
      - High transaction throughput performance
      - Low latency of transaction confirmation
      - Privacy and confidentiality of transactions and data pertaining to business transactions
      - Participants must be identified/identifiable
    - - This means that while the participants may not fully trust one another (they may, for example, be competitors in the same industry), a network can be operated under a governance model that is built off of what trust does exist between participants, such as a legal agreement or framework for handling disputes.
      - Pluggable consensus protocols
        
        Crush Fault Tolerance (CFT) for performance
        
        Traditional BFT for security
        
        In the currently available releases, Fabric offers a CFT ordering service implemented with Kafka and Zookeeper. In subsequent releases, Fabric will deliver a Raft consensus ordering service implemented with etcd/Raft and a fully decentralized BFT ordering service.
      - Privacy and confidentiality
    - - A pluggable ordering service establishes consensus on the order of transactions and then broadcasts blocks to peers.
      - A pluggable membership service provider is responsible for associating entities in the network with cryptographic identities.
      - An optional peer-to-peer gossip service disseminates the blocks output by ordering service to other peers.
      - Smart contracts (“chaincode”) run within a container environment (e.g. Docker) for isolation. They can be written in standard programming languages but do not have direct access to the ledger state.
      - The ledger can be configured to support a variety of DBMSs.
      - A pluggable endorsement and validation policy enforcement that can be independently configured per application.
    - - Zero knowledge proofs (ZKP) are another area of research being explored to address this problem, the trade-off here being that, presently, computing a ZKP requires considerable time and computational resources. Hence, the trade-off in this case is performance for confidentiality.
      - But this is very crucial for Hyperledger Fabric, thus ZCASH part time is a great choice! (And working remotely and then on your own startup too)
  - - - Download all the dependencies
        
        Launch the network
        
        Install the application with npm
        
        Doc
        
        pubK
        
        privK
        
        admin
        
        Enroll the Admin User
        
        5.
        
        The most important of which is the fabric-network class; it enables an application to use identities, wallets, and gateways to connect to channels, submit transactions, and wait for notifications.
        
        How The startFabric.sh works?
        
        start everything
      - bootstrap.sh
        
        sample install
        
        binaries install
        
        docker install (images)
    - - Clean history and build the network
      - Build and then install application
      - :star: Enroll Admin
        
        Result: in the wallet you will have cert, privK, and pubK
        
        All the information of artifacts are also stored in connection.json
      - Enroll User
    - - Chaincode For Developer
        
        Important notes: :star:
        
        If the called chaincode is on a different channel from the calling chaincode, only read query is allowed
        
        That is, the called chaincode on a different channel is only a Query, which does not participate in state validation checks in subsequent commit phase.
        
        Chaincode Shim API
        
        chaincode interface
        
        Languages
        
        NodeJS
        
        Go
        
        JAVA
        
        Peer API
        
        Chaincode Development Lifecycle
        
        Normally chaincodes are started and maintained by peer. However in “dev mode”, chaincode is built and started by the user. This mode is useful during chaincode development phase for rapid code/build/run/debug cycle turnaround.
        We start “dev mode” by leveraging pre-generated orderer and channel artifacts for a sample dev network. As such, the user can immediately jump into the process of compiling chaincode and driving calls.
        
        Chaincode ACL :red_flag:
        
        Only the client (submitter) can update
        
        Client Identity Chaincode Library
        
        Make ACL based on
        
        The client MSP ID
        
        The attribute associated with the client identity
        
        Attributes are just key-value pairs associated with an identity.
        
        Assumptions
        
        The stub variable used in chaincode is ChaincodeStubInterface
        
        Add import "github.com/hyperledger/fabric/core/chaincode/shim/ext/cid" to your chaincode
        
        Managing attributes with Fabric CA
        
        Chaincode Encryption :red_flag:
      - Chaincode for operator
      - How to run a chaincode :!?::
        
        Contents required: cli, chaincode, peer, orderer
        
        Three terminals (Given the sample network)
        
        T1: Starting the network (will keep running)
        
        docker-compose -f docker-compose-simple.yaml up
        
        he above starts the network with the SingleSampleMSPSolo orderer profile and launches the peer in “dev mode”. It also launches two additional containers - one for the chaincode environment and a CLI to interact with the chaincode. The commands for create and join channel are embedded in the CLI container, so we can jump immediately to the chaincode calls.
        
        Without this the docker bash won't works
        
        T2: Build and start the chaincode (will keep running)
        
        docker exec -it chaincode bash
        
        Launching the docker bash with (chaincode) container
        
        cd DIR_WITH_CHAINCODE; go build # compile the chaincode
        
        T3: Using the chaincode
        
        docker exec -it cli bash # notice that here (cli) is the client peer container
        
        peer chaincode install -p chaincodedev/chaincode/YOUR_CHAINCODE_NAME -n mycc -v 0
        peer chaincode instantiate -n mycc -v 0 -c '{"Args":["a","10"]}' -C myc
        
        E.g. depending on implementation
        
        peer chaincode invoke -n mycc -c '{"Args":["set", "a", "20"]}' -C myc
        
        peer chaincode query -n mycc -c '{"Args":["query","a"]}' -C myc
        
        Important: If you want to add your own chain code, follow these steps:
        
        Add the chaincode to your local "fabric-sample-x.x.x/chaincode" subdirectory
        
        Run the three terminal steps in step (2)
        
        Test
    - - Configuration :question: (How do you accomplish this?)
        
        To setup an instance of the MSP, its configuration needs to be specified locally at each peer and orderer (to enable peer, and orderer signing), and on the channels to enable peer, orderer, client identity validation, and respective signature verification (authentication) by and for all channel members.
    - - VSCC (Validation System Chaincode) Makes the following determines
        
        All the certificates are valid
        
        i.e. they are all valid signatures from valid certificates over the expected messages
        
        There enough endorsers signed
        
        Endorsements from expected sources
      - Four roles are supported: member, admin, client, and peer.
        
        MSP.ROLE
        
        e.g. org1.admin or org2.member
      - AND and OR syntax
        
        AND(Org1.member1, Org1.member2): both members need to sign and certificate for the tx.
        
        OR(Org1.admin1, Org2.admin2) either admin sign is enough
        
        OR(Org1.admin1, AND(Org2.member2, Org2.member3)): either the administrator of organization 1 signed, or both member 2 and 3 in organization two signed will work