בצע עסקאות ציבוריות ופרטיות ב-JPMorgan Quorum blockchain באמצעות Web3

מִניָן הוא בלוקצ'יין מבוסס Ethereum שפותח על ידי JPMorgan ולאחרונה הפך לפלטפורמת הספרים המבוזרים הראשונה המוצעת על ידי Microsoft Azure.

Quorum תומך בעסקאות פרטיות וציבוריות ויש לו מקרי שימוש מסחריים רבים.

במאמר זה נבחן תרחיש אחד כזה - פריסת רשת פנקסים מבוזרת בין סופרמרקט לבעל מחסן על מנת לספק מידע עדכני על טמפרטורת המחסן.

הקוד המשמש במדריך זה נמצא ב מאגרים ב- GitHub.

המאמר מכסה:

• יצירת חוזה חכם;
• פריסה של רשת Quorum באמצעות ערמת שרשרת;
• עסקאות ציבוריות בקוורום;
• עסקאות פרטיות בקוורום.

לשם המחשה, אנו משתמשים בתרחיש לניטור טמפרטורה במחסנים של חברי רשת Quorum בתוך האינטרנט של הדברים (IoT).

הֶקשֵׁר

קבוצה של חברות מחסנים מתאחדת בקונסורציום כדי לאחסן יחד מידע ולהפוך תהליכים לאוטומטיים בבלוקצ'יין. לשם כך, חברות החליטו להשתמש בקוורום. במאמר זה נתייחס לשני תרחישים: עסקאות ציבוריות ועסקאות פרטיות.

עסקאות נוצרות על ידי משתתפים שונים כדי ליצור אינטראקציה עם הקונסורציום שאליו הם שייכים. כל עסקה פורסת חוזה או קוראת לפונקציה בחוזה כדי להעלות נתונים לרשת. פעולות אלו משוכפלות לכל הצמתים ברשת.

עסקאות ציבוריות זמינות לצפייה על ידי כל משתתפי הקונסורציום. עסקאות פרטיות מוסיפות רובד של סודיות וזמינות רק למשתתפים שיש להם זכויות לעשות זאת.

עבור שני התרחישים, אנו משתמשים באותו חוזה לצורך בהירות.

חוזה חכם

להלן חוזה חכם פשוט שנוצר עבור התרחיש שלנו. יש לו משתנה ציבורי temperature, שניתן לשנות באמצעות set ולקבל לפי השיטה 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;
  }
}

על מנת שהחוזה יעבוד איתו web3.js, יש לתרגם אותו לפורמט ABI ולקוד בתים. שימוש בפונקציה formatContractלהלן מרכיב את החוזה באמצעות solc-js.

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

החוזה שהושלם נראה כך:

// 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

כעת, כשהחוזה מוכן, נפרוס את הרשת נפרוס את החוזה.

פריסת צומת

פריסת צומת יכולה להיות די עתירת עבודה וניתן להחליף תהליך זה באמצעות שירות ערמת שרשרת.

להלן התהליך לפריסת רשת Quorum עם קונצנזוס Raft ושלושה צמתים.

ראשית, בואו ניצור פרויקט ונקרא לו Quorum Project:

בואו ניצור רשת Quorum עם קונצנזוס Raft ב-Google Cloud Platform:

בואו נוסיף עוד שני צמתים לצומת שכבר נוצר כברירת מחדל:

שלושה צמתים רצים:

דף פרטי הצומת מציג את נקודת הקצה של ה-RPC, המפתח הציבורי וכו'.

הרשת פרוסה. עכשיו בואו נפרוס חוזים חכמים ונבצע עסקאות באמצעות web3.js.

עסקאות ציבוריות

הֶקשֵׁר

לטמפרטורת המחסן חשיבות רבה בהפחתת עלויות, במיוחד עבור מוצרים המיועדים לאחסון בטמפרטורות מתחת לאפס.

על ידי מתן אפשרות לחברות לחלוק את הטמפרטורה החיצונית של מיקומן הגיאוגרפי בזמן אמת ולתעד אותה בספר חשבונות בלתי ניתן לשינוי, משתתפי הרשת מפחיתים עלויות וזמן.

נבצע שלוש משימות, המומחשות בתרשים:

1. אנו נפרוס את החוזה באמצעות צומת 1:

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

2. הגדר את הטמפרטורה באמצעות צומת 2 ב-3 מעלות:

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

3. צומת 3 יקבלו מידע מהחוזה החכם. החוזה יחזיר את הערך 3 מעלות:

   const temp = await getTemperature(raft3Node, contractAddress);
   console.log(‘Retrieved contract Temperature’, temp);

   לאחר מכן, נבחן כיצד לבצע עסקה ציבורית ברשת Quorum באמצעות web3.js.

אנו יוזמים מופע באמצעות RPC עבור שלושה צמתים:

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,
 },
);

בואו נפרוס את החוזה החכם:

// 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 מספק שתי שיטות לאינטראקציה עם החוזה: call и send.

בואו נעדכן את טמפרטורת החוזה על ידי ביצוע set בשיטת 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;
  });
}

לאחר מכן אנו משתמשים בשיטת web3 call כדי לקבל את טמפרטורת החוזה. שימו לב שהשיטה call מבוצע על צומת מקומי והעסקה לא תיווצר בבלוקצ'יין.

// 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);
}

עכשיו אתה יכול לרוץ public.js כדי לקבל את התוצאה הבאה:

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

לאחר מכן, נוכל להציג את הערכים ב-Quorum Explorer בחלונית Chainstack, כפי שמוצג להלן.

כל שלושת הצמתים קיימו אינטראקציה והעסקאות עודכנו:

1. העסקה הראשונה פרסה את החוזה.
2. העסקה השנייה קבעה את טמפרטורת החוזה ל-3 מעלות.
3. הטמפרטורה מתקבלת דרך צומת מקומי, כך שלא נוצרת עסקה.

עסקאות פרטיות

הֶקשֵׁר

דרישה נפוצה של ארגונים היא הגנת מידע. כדוגמה, שקול תרחיש שבו סוּפֶּרמַרקֶט שוכרת חלל מחסן לאחסון פירות ים מנפרד מוֹכֵר:

• מוֹכֵר באמצעות חיישני IoT, קורא ערכי טמפרטורה כל 30 שניות ומשדר אותם לסופר מרקט;
• ערכים אלה צריכים להיות זמינים בלבד אל המוכר и לסופר מרקט, מרושת על ידי קונסורציום.

נשלים את ארבע המשימות המוצגות בתרשים למעלה.

• אנו משתמשים באותם שלושה צמתים מהתרחיש הקודם כדי להדגים עסקאות פרטיות:
• סופרמרקט פורס חוזה חכם שהוא פרטי סוּפֶּרמַרקֶט и מוֹכֵר.
• הצד השלישי אין לו זכות גישה לחוזה החכם.

נכנה את השיטות get и set בשם סוּפֶּרמַרקֶט и מוֹכֵר להדגים עסקה פרטית של Quorum.

1. אנו נפרוס חוזה פרטי עבור המשתתפים סופרמרקט и מוֹכֵר דרך משתתף סופרמרקט:

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

2. בואו נקבע את הטמפרטורה מ צד שלישי (צומת חיצוני) וקבל את ערך הטמפרטורה:

   // 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}`);

3. בואו נקבע את הטמפרטורה מ מוֹכֵר (צומת פנימי) וקבל את ערך הטמפרטורה:

   הטמפרטורה בתרחיש זה אמורה להחזיר את הערך 12 מהחוזה החכם. שימו לב מוֹכֵר כאן יש גישה מורשית לחוזה החכם.

   // 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}`);

4. אנחנו מקבלים את הטמפרטורה מ צד שלישי (צומת חיצוני):

   בשלב 3 הטמפרטורה נקבעה ל-12, אבל הצד השלישי אין לו גישה לחוזה החכם. לכן ערך ההחזרה חייב להיות null.

   // This returns null
   const temp3 = await getTemperature(raft3Node, contractAddress);
   console.log(`[Node3] temp retrieved from external nodes after update ${temp}`);

   לאחר מכן, נסתכל מקרוב על ביצוע עסקאות פרטיות ברשת Quorum עם web3.js. מכיוון שרוב הקוד זהה עבור עסקאות ציבוריות, נדגיש רק את החלקים השונים עבור עסקאות פרטיות.

שימו לב שהחוזה שהועלה לרשת אינו ניתן לשינוי, ולכן יש להעניק גישה מורשית לצמתים המתאימים על ידי הפעלת החוזה הציבורי בזמן פריסת החוזה, ולא לאחר מכן.

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;
  });
}

עסקאות פרטיות מבוצעות באופן דומה - על ידי הכללת המפתח הציבורי של המשתתפים בזמן הביצוע.

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;
  });
}

עכשיו אנחנו יכולים לרוץ private.js עם התוצאות הבאות:

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

סייר הקוורום ב-Chainstack יציג את הדברים הבאים:

• פריסת החוזה מהמשתתף סופרמרקט;
• הגשמה SetTemperature מ צד שלישי;
• הגשמה SetTemperature ממשתתף מוֹכֵר.

כפי שאתה יכול לראות, שתי העסקאות הושלמו, אבל רק העסקה מהמשתתף מוֹכֵר עדכן את הטמפרטורה בחוזה. לפיכך, עסקאות פרטיות מספקות אי-שינוי, אך יחד עם זאת אינן חושפות נתונים לצד שלישי.

מסקנה

בדקנו מקרה שימוש מסחרי עבור Quorum כדי לספק מידע טמפרטורה עדכני במחסן על ידי פריסת רשת בין שני גורמים - סופרמרקט ובעל מחסן.

הראינו כיצד ניתן לשמור מידע טמפרטורה עדכני באמצעות עסקאות ציבוריות ופרטיות כאחד.

יכולים להיות הרבה תרחישים של יישומים, וכפי שאתה יכול לראות, זה בכלל לא קשה.

נסה, נסה להרחיב את הסקריפט שלך. יתר על כן, תעשיית טכנולוגיית הבלוקצ'יין יכול לגדול כמעט פי עשרה עד 2024.

מקור: www.habr.com