Perficere negotia publica et privata in JPMorgan Quorum impedimento utens Web3

Quorum est stipes Ethereum-substructio ab JPMorgano evoluta et recentissima primum suggestum crepidinis distributum ab Microsoft Azure oblatum est.

Quorum causas privatas et publicas sustinet et multos usus mercatorum habet.

In hoc articulo, unum talem missionem examinabimus - instruere retis distributi inter macellum et possessorem horreorum, ut notitias recentes de temperie horrei praebeant.

Codex in hoc doceo in repositoria in GitHub.

Articulus tegit:

dolor contractus creatio;
Quorum usura network instruere Vinculum;
Quoru publica negotia;
QUORUM PRIVATIS REBUS.

Ad illustrandum, missionem adhibemus ad vigilantiam temperatam in apothecae sodalium Quorum retis in Interreti Rerum (IOT).

context

Coetus societates horreorum in consortio coniungit cum informationibus et processibus automatis in impedimento coniunctim coniungit. Ad hoc, societatibus quorum uti placuit. In hoc articulo duos missiones operiemus: publicas res et privatas res.

Transactiones a diversis participantibus penitus fiunt cum consortio cuius sunt. Utraque transactiones vel contractus disponit vel munus vocat in contractu ad notitias fasciculos retis. Hae actiones omnibus nodis in retis replicantur.

Publica negotia praesto sunt ad videndum ab omnibus participantibus consortium. Negotiationes privatae lavacrum secreto addunt et praesto sunt iis tantum participes qui iura hoc faciunt.

Utrisque missionibus eodem contractu ad claritatem utimur.

Dolor contractus

Infra est simplex contractus captiosus pro nostro missione creatus. Publica variabilis est temperaturequae mutari utens set ac per modum get.

pragma solidity ^0.4.25;
contract TemperatureMonitor {
  int8 public temperature;
function set(int8 temp) public {
    temperature = temp;
  }
function get() view public returns (int8) {
    return temperature;
  }
}

Ut contractus operari web3.jsin ABI formato et bytecode vertendum est. Munus utens formatContractinfra conscribit contractus usura solc-js.

function formatContract() {
  const path = './contracts/temperatureMonitor.sol';
  const source = fs.readFileSync(path,'UTF8');
return solc.compile(source, 1).contracts[':TemperatureMonitor'];
}

Contractus contractus similis est:

// interface
[ 
  { 
    constant: true,
    inputs: [],
    name: ‘get’,
    outputs: [Array],
    payable: false,
    stateMutability: ‘view’,
    type: ‘function’ 
  },
  { 
    constant: true,
    inputs: [],
    name: ‘temperature’,
    outputs: [Array],
    payable: false,
    stateMutability: ‘view’,
    type: ‘function’ 
  },
  {
    constant: false,
    inputs: [Array],
    name: ‘set’,
    outputs: [],
    payable: false,
    stateMutability: ‘nonpayable’,
    type: ‘function’ 
  }
]

// bytecode
0x608060405234801561001057600080fd5b50610104806100206000396000f30060806040526004361060525763ffffffff7c01000000000000000000000000000000000000000000000000000000006000350416636d4ce63c81146057578063adccea12146082578063faee13b9146094575b600080fd5b348015606257600080fd5b50606960ae565b60408051600092830b90920b8252519081900360200190f35b348015608d57600080fd5b50606960b7565b348015609f57600080fd5b5060ac60043560000b60c0565b005b60008054900b90565b60008054900b81565b6000805491810b60ff1660ff199092169190911790555600a165627a7a72305820af0086d55a9a4e6d52cb6b3967afd764ca89df91b2f42d7bf3b30098d222e5c50029

Nunc ut contractus paratus est, retiaculum explicabimus et contractus explicabimus.

Node instruere

Nodus explicans satis intensus esse potest et hic processus substitui potest utendo servitio Vinculum.

Infra est processus explicandi Quorum retis cum consensu Raft et tribus nodis.

Primum consilium crearemus Quorum Project:

Quorum network cum Raft consensum crearemus in Google Cloud Platform:

Duos nodos nodi iam per defaltam creatos addamus:

Nodi tres cursus;

Nodi singula pagina ostendit RPC endpunctum, clavem publicam, etc.

Retis explicatur. Nunc pandemus captiosam pactiones et res gestas utendo web3.js.

Publica transactions

context

CELLA temperatura magni momenti est in redigendis sumptibus, praesertim pro fructibus destinatis ad nullas temperaturas sub-reponendas.

Societates permittens communicare extra temperiem locorum locorum eorum in tempore reali et in motu immutabili recitare, participes retis sumptibus et tempore minuere.

Tria opera faciemus, in schemate illustrata;

Nos contractus per explicandam nodi 1:

const contractAddress = await deployContract(raft1Node);
console.log(`Contract address after deployment: ${contractAddress}`);

Pone temperatus per nodi 2 per gradus III:

const status = await setTemperature(raft2Node, contractAddress, 3);
console.log(`Transaction status: ${status}`);

nodi 3 informatione a dolor contractus. Contractus reddet valorem 3 gradus:
```
const temp = await getTemperature(raft3Node, contractAddress);
console.log(‘Retrieved contract Temperature’, temp);
```
Deinceps videbimus quomodo rem publicam exequendam in quorum retis utendo web3.js.

Incipimus instantia per RPC ad tres nodos:

const raft1Node = new Web3(
 new Web3.providers.HttpProvider(process.env.RPC1), null, {
   transactionConfirmationBlocks: 1,
 },
);
const raft2Node = new Web3(
 new Web3.providers.HttpProvider(process.env.RPC2), null, {
   transactionConfirmationBlocks: 1,
 },
);
const raft3Node = new Web3(
 new Web3.providers.HttpProvider(process.env.RPC3), null, {
   transactionConfirmationBlocks: 1,
 },
);

Pandemus dolor contractus;

// returns the default account from the Web3 instance initiated previously
function getAddress(web3) {
  return web3.eth.getAccounts().then(accounts => accounts[0]);
}
// Deploys the contract using contract's interface and node's default address
async function deployContract(web3) {
  const address = await getAddress(web3);
// initiate contract with contract's interface
  const contract = new web3.eth.Contract(
    temperatureMonitor.interface
  );
return contract.deploy({
    // deploy contract with contract's bytecode
    data: temperatureMonitor.bytecode,
  })
  .send({
    from: address,
    gas: '0x2CD29C0',
  })
  .on('error', console.error)
  .then((newContractInstance) => {
    // returns deployed contract address
    return newContractInstance.options.address;
  });
}

web3.js Duo modi sunt mutuo contractus: call и send.

Lets renovatio contractus temperatus exequendo set per modum web3 send.

// get contract deployed previously
async function getContract(web3, contractAddress) {
  const address = await getAddress(web3);
return web3.eth.Contract(
    temperatureMonitor.interface,
    contractAddress, {
      defaultAccount: address,
    }
  );
}
// calls contract set method to update contract's temperature
async function setTemperature(web3, contractAddress, temp) {
  const myContract = await getContract(web3, contractAddress);
return myContract.methods.set(temp).send({}).then((receipt) => {
    return receipt.status;
  });
}

Deinde utimur methodo web3 call habere contractum tortor. Lorem quod modus call fit in nodi locali et transactio in impedimento non creabitur.

// calls contract get method to retrieve contract's temperature
async function getTemperature(web3, contractAddress) {
  const myContract = await getContract(web3, contractAddress);
return myContract.methods.get().call().then(result => result);
}

Nunc currere potes public.js ut hoc eventum;

// Execute public script
node public.js
Contract address after deployment: 0xf46141Ac7D6D6E986eFb2321756b5d1e8a25008F
Transaction status: true
Retrieved contract Temperature 3

Deinde inspicere possumus entries in Quorum rimor in tabula Vinstack, ut infra patebit.

Omnes tres nodi interacted et operationes renovatae sunt:

Primus contractus transactionem direxit.
Secundum transactionem constituit contractus temperatus ad 3 gradus.
Temperatura per nodi localem recipitur, ita transactio nulla creatur.

Privata transactions

context

Communis postulatio consociationum est notitia tutelae. Exempli gratia, considera missionem in qua Supermarket redditus horreis spatium nendae seafood a separato Vendor:

Vendor sensoriis utens IoT legit, temperaturas omnes 30 secundas aestimat et eas transmittit Ad forum;
hi valores modo praesto sint Ad venditorem и Ad forumretis a consortio.

Quattuor munia perficiemus in schemate supra illustrata.

Eisdem tribus nodis e missione praecedente utimur ad res privatas demonstrandas:
forum dolor contractus explicat privatus to Supermarket и Vendor.
Tertium latus ius dolor contractus aditus non habet.

Invocabimus modi get и set pro Supermarket и Vendor ad demonstrandum privatum, Quorum transactionem.

Privatus contractus participantium explicabimus forum и Vendor per participem forum:

const contractAddress = await deployContract(
raft1Node,
process.env.PK2,
);
console.log(`Contract address after deployment: ${contractAddress}`);

In posuere tortor a Tertia pars (nodi externi) et obtine temperatus valorem;

// Attempts to set Contract temperature to 10, this will not mutate contract's temperature
await setTemperature(
raft3Node,
contractAddress,
process.env.PK1,
10,
);
// This returns null
const temp = await getTemperature(raft3Node, contractAddress);
console.log(`[Node3] temp retrieved after updating contract from external nodes: ${temp}`);

In posuere tortor a Vendor (nodi internus) et temperatus valorem posside:

Temperatus in hoc missione debet reddere valorem XII ex acri contractu. Lorem quod Vendor hinc aditum ad captiosam contractus habet auctoritatem.

// Updated Contract temperature to 12 degrees
await setTemperature(
raft2Node,
contractAddress,
process.env.PK1,
12,
);
// This returns 12
const temp2 = await getTemperature(raft2Node, contractAddress);
console.log(`[Node2] temp retrieved after updating contract from internal nodes: ${temp2}`);

Nos adepto temperatus a Tertia pars (nodi externi);

In gradu 3 temperatura ad 12 sed Tertium latus aditus ad captiuitatem non habet. Ergo valor reditus nullus debet esse.
```
// This returns null
const temp3 = await getTemperature(raft3Node, contractAddress);
console.log(`[Node3] temp retrieved from external nodes after update ${temp}`);
```
Deinde propius inspiciemus in negotiis privatis faciendis in quorum retis cum web3.js. Cum in plerisque codicibus idem sit rerum publicarum, eas tantum partes, quae privatis negotiis diversae sunt, illustrabimus.

Nota contractum ad retiaculum impositum immutabile esse, ideo accessus permissus opportunis nodi concedendus est, quo pacto contractus publicus tempore contractus explicatur, non post.

async function deployContract(web3, publicKey) {
  const address = await getAddress(web3);
  const contract = new web3.eth.Contract(
    temperatureMonitor.interface,
  );
return contract.deploy({
    data: temperatureMonitor.bytecode,
  })
  .send({
    from: address,
    gas: ‘0x2CD29C0’, 
    // Grant Permission to Contract by including nodes public keys
    privateFor: [publicKey],
  })
  .then((contract) => {
    return contract.options.address;
  });
}

Simili modo negotia privata fiunt - includendo clavem publicam participantium tempore executionis.

async function setTemperature(web3, contractAddress, publicKey, temp) {
  const address = await getAddress(web3);
  const myContract = await getContract(web3, contractAddress);
return myContract.methods.set(temp).send({
    from: address,
    // Grant Permission by including nodes public  keys
    privateFor: [publicKey],
  }).then((receipt) => {
    return receipt.status;
  });
}

Nunc currere possumus private.js cum sequentibus eventibus:

node private.js
Contract address after deployment: 0x85dBF88B4dfa47e73608b33454E4e3BA2812B21D
[Node3] temp retrieved after updating contract from external nodes: null
[Node2] temp retrieved after updating contract from internal nodes: 12
[Node3] temp retrieved from external nodes after update null

Quorum explorator in Chainstack sequentibus ostendet:

instruere contractus participem forum;
supplicium SetTemperature ex Tertia pars;
supplicium SetTemperature ex participem Vendor.

Ut videre potes, utraque res perficitur, sed tantum transactionem participem Vendor in contractu temperatus renovavit. Ita res privatae immutabilitatem praebent, sed simul notitias tertiae parti non revelant.

conclusio,

Quorum causam ad usum commercialem inspeximus ut informationes temperaturas in horreis up-date praeberet instruendo retis inter duas partes - macellum et horreum possessoris.

Ostendimus quomodo temperaturae notitiae up-dates per res tam publicas quam privatas defendi possint.

Multum applicatio missionum potest esse et, ut vides, non est difficile.

Experimentum, scribe litteras tuas. Praeterea, impedimentum technologiae industriae potest crescere quasi decumo a MMXXIV ".

Source: www.habr.com

Quorum negotiationes publicas et privatas in JPMorgan perfice, quorum impedimento utens Web3

context

Dolor contractus

Node instruere

Publica transactions

context

Privata transactions

context

conclusio,

Add a comment Отменить ответ