ნამდვილად რთულია ბლოკჩეინის, როგორც ბექენდის განვითარება?

ეს სტატია არ ეხება კრიპტოვალუტას ან დეცენტრალიზებულ ფინანსებს. ამის ნაცვლად, ჩვენ შევისწავლით საჯარო EVM ბლოკჩეინებს და როგორ შეიძლება მათი გამოყენება თქვენს შემდეგ პროექტში, თქვენი კონკრეტული საჭიროებიდან და მიზნებიდან გამომდინარე. მე ჩავუღრმავდები დადებითი, უარყოფითი მხარეები და პრაქტიკული მაგალითები 0xweb ბიბლიოთეკის გამოყენებით, რომელზეც მე ვმუშაობდი.

§ პრო და საწინააღმდეგო

• 🚀 ნულოვანი დაყენების დრო

ის უკვე მუშაობს. უბრალოდ განსაზღვრეთ თქვენი მონაცემთა მოდელი, როგორც კონტრაქტი და განათავსეთ იგი.

• ✨ ნულოვანი მოვლა

თქვენი მონაცემების ატვირთვის შემდეგ, ისინი ხელმისაწვდომი იქნება მანამ, სანამ ბლოკჩეინი მუშაობს. შემიძლია ვივარაუდო, რომ ეს ბევრად უფრო გრძელი იქნება ვიდრე თქვენი სხვა ჰოსტინგის გამოწერა.

• 💯 100% წაკითხვის დრო; 100%-თან ახლოს ჩაწერის დრო

ბლოკჩეინში კითხვისა და წერის პროცესების გამიჯვნა უზრუნველყოფს წაკითხვის ოპერაციების 100%-იან მუშაობას, განსაკუთრებით მაშინ, როდესაც გამოიყენება მრავალი RPC პროვაიდერი ზედმეტობისთვის.

• 🛡️ უსაფრთხო

ბლოკჩეინები არსებითად უზრუნველყოფენ უსაფრთხოების უფრო მაღალ დონეს, ვიდრე ჩვეულებრივი ჰოსტინგის გადაწყვეტილებები. მონაცემთა ექსპლუატაცია შესაძლებელია მხოლოდ იმ შემთხვევაში, თუ დაუცველობა არსებობს თქვენი მონაცემთა მოდელის ლოგიკაში.

• 📖 გახსენით მონაცემები

თუ დაშიფრული არ არის, თქვენი მონაცემები რჩება ღია, ხელმისაწვდომი და დამოწმებული ვინმეს მიერ, რაც ხელს უწყობს გამჭვირვალობას.

• 🖧 DNS-ის გარეშე

დომენის სახელები არასაჭიროა ამ ტიპის ბექენდისთვის. ამის ნაცვლად, შეიძლება გამოყენებულ იქნას დეცენტრალიზებული კვანძების პროვაიდერების სია, რაც კლიენტის ბიბლიოთეკებს საშუალებას აძლევს აირჩიონ ყველაზე ეფექტური ვარიანტი საბოლოო მომხმარებლებისთვის.

• 🤝 ენდე

ზემოაღნიშნული ფუნქციების წყალობით, ბლოკჩეინზე დაფუძნებული ბექენდები არსებითად აშენებენ მომხმარებლის ნდობას მონაცემთა უსაფრთხოების და 24/7 ხელმისაწვდომობის უზრუნველყოფის გზით, მაშინაც კი, თუ პროექტის შენარჩუნება და განვითარება შეჩერდება.

• 🧩 ურთიერთგაგება მესამე მხარის მონაცემთა მოდელებთან

თქვენ შეგიძლიათ დააკავშიროთ სხვა მონაცემთა მოდელები, რომლებიც ინახება ბლოკჩეინზე, ან სხვა პროექტები შეიძლება დაფუძნდეს თქვენს მონაცემთა მოდელზე.

• ⚙️ გაფართოება

მომხმარებლებს შეუძლიათ გამოიყენონ მესამე მხარის მრავალი პროექტი მოქმედებების მონიტორინგის ან ავტომატიზაციისთვის, რაც მნიშვნელოვნად აფართოებს თქვენი მონაცემთა მოდელის შესაძლებლობებს.

• 📜 ისტორია და დროში მოგზაურობა

მონაცემების წვდომა შესაძლებელია წარსულის ნებისმიერი წერტილიდან.

• 📡 ივენთები და ივენთ-სტრიმები

ჩატვირთეთ ისტორიული მორგებული მოვლენები ან გამოიყენეთ WebSockets რეალურ დროში შემომავალი მოვლენების მოსასმენად, რაც საშუალებას აძლევს აპლიკაციის დინამიურ პასუხებს.

• 👤 ჩაშენებული მომხმარებლის იდენტიფიკაცია

„საფულის“ კონცეფცია მომხმარებლებს საშუალებას აძლევს, დაადასტურონ საკუთარი თავი შეტყობინებების ხელმოწერით, რაც უზრუნველყოფს მომხმარებლის უპრობლემოდ და დეცენტრალიზებულ იდენტიფიკაციას.

• 📝 მიეცით მომხმარებლებს მონაცემების შეცვლა ან გაფართოების უფლება

მომხმარებლებს შეუძლიათ შეცვალონ ან გააფართოვონ მონაცემები თქვენს მეხსიერებაში, თქვენ მიერ განსაზღვრული ნებართვების საფუძველზე. რაც მთავარია, ამ ცვლილებების ხარჯებს თავად მომხმარებლები იღებენ. დაბალფასიანი ბლოკჩეინის არჩევით, ეს საკომისიო შეიძლება დარჩეს უმნიშვნელო, ხშირად შეადგენს მხოლოდ რამდენიმე ცენტს თითო ტრანზაქციაზე.

• 🌐 უზარმაზარი და მუდმივად განვითარებადი ეკოსისტემა

• მრავალი მყარი მოდული, რომელიც შეგიძლიათ გამოიყენოთ თქვენი მონაცემთა მოდელის ფუნქციონირების გასაუმჯობესებლად.
• ბევრი ღია და უფასო სერვისი, ისევე როგორც ის, ვინც გთავაზობთ უფასო გეგმებს, ხელმისაწვდომია. ჩვეულებრივი პრაქტიკაა ბლოკჩეინის საზოგადოებაში უფასო გეგმების უზრუნველყოფა, რომლებიც ხშირად საკმარისია წარმოების საჭიროებისთვის.

§ კონტრა

• 💾 შენახვა ძვირია 😢

მიუხედავად იმისა, რომ ის მიჰყვება რეალურ გადახდის მოდელს, თქვენ იხდით მხოლოდ იმ სლოტებში, რომლებსაც ინახავთ. თითოეულ SLOT-ს აქვს 32 ბაიტი, ჯდება 20000 გაზი ახალი მონაცემების ჩაწერა ან 5000 გაზი მონაცემთა განახლებისთვის. მაგალითისთვის ავიღოთ პოლიგონი, 30-გვეი გაზის ფასით და 0,60$ POL ფასით.

20000გაზი × 30გვეი = 0,008 POL × 0,60 $ = 0,00032 დოლარი

ეს ბევრია, ამიტომ „Floppy Disk“ emoji საუკეთესოდ წარმოადგენს შენახვის ოდენობას, რაც იმას ნიშნავს, რომ ის საუკეთესოდ შეეფერება მცირე მონაცემთა ნაკრებებს, თუ გადაიხდით საკუთარ თავზე. თუმცა, უნიკალური უპირატესობა ის არის, რომ მომხმარებლებს შეუძლიათ გაიღონ საკუთარი შენახვისა და მოქმედებების ხარჯები, რაც სხვა ტექნოლოგიებში არ არის ნაპოვნი. მიუხედავად იმისა, რომ ამ მიდგომამ შეიძლება ხელი შეუშალოს თქვენი აპლიკაციის მასობრივ მიღებას, ის ფართოდ არის მიღებული ბლოკჩეინის საზოგადოებაში.

• 🧮 გამოთვლა შეზღუდულია 😢

ბლოკჩეინის მონაცემთა მოდელები მხარს უჭერენ ფუნქციებს მონაცემებთან ურთიერთობისთვის, მაგრამ მათ გამოთვლით შესაძლებლობებს აქვს შეზღუდვები. ეს შეზღუდვები დამოკიდებულია RPC კვანძებზე, რომლებსაც იყენებთ წაკითხვის მოქმედებებისთვის და მკაცრი GAS ლიმიტები, რომლებიც დაწესებულია ჩაწერის მოქმედებებზე (ტრანზაქციაზე). მიუხედავად იმისა, რომ ძირითადი ოპერაციები, მარყუჟები და უფრო ღრმა ზარის სტეკები ჩვეულებრივ მართვადია, ბლოკჩეინი შეუფერებელია მძიმე გამოთვლითი დატვირთვისთვის.

ამის თქმით, მონაცემთა შედარებით მცირე ზომის გათვალისწინებით, როგორც წესი, არსებული ლიმიტები, როგორც წესი, საკმარისია გამოყენების შემთხვევების უმეტესობისთვის.

§ punctum neutrum

• 🧬 მონაცემთა სტრუქტურა, Solidity ენა, SDKs

თუ თქვენ ახალი ხართ ბლოკჩეინის განვითარებაში, შეიძლება გსმენიათ, რომ ეს რთული და რთულია მისი დაწყება. თუმცა ეს სიმართლეს არ შეესაბამება. ბლოკჩეინის განვითარება იყენებს ნაცნობ ცნებებს, სემანტიკას და სინტაქსს, რაც აადვილებს სწავლას, ვიდრე შეიძლება ჩანდეს.

§ დემო: აპლიკაციის ვერსიის საცავი

https://github.com/0xweb-org/examples-backend

ამ სტატიისთვის, მოდით შევქმნათ აპლიკაციის ვერსიის მენეჯერის კონტრაქტი. წარმოიდგინეთ, რომ თქვენ გაქვთ დესკტოპის აპლიკაცია, რომელიც მოითხოვს backend-ს ახალი ვერსიების შესამოწმებლად და ახალი ვერსიის გამოქვეყნებისას ჩამოტვირთვის ბმულის მისაღებად. ქვემოთ მოცემულია საბოლოო კონტრაქტი, რომელიც ასახავს ძირითად კონცეფციებს:

 import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol"; struct Package { uint version; uint timestamp; string url; bytes32 sha256; } contract AppVersionManager is Ownable { // Events that are emitted on data updates event NewApplicationInfo(); event NewPackage(uint version, uint timestamp); // Custom error, when title for the application is empty error TitleIsEmpty(); // Some application information string public title; // @TODO: add further application related properties if required // Latest package Package public package; // Track all versions and their packages mapping (uint => Package) public packages; // List of all previous versions uint[] public versions; constructor () Ownable(msg.sender) { } function updateInfo(string calldata newTitle) external onlyOwner { if (bytes(newTitle).length == 0) { revert TitleIsEmpty(); } title = newTitle; emit NewApplicationInfo(); } function updatePackage(Package calldata newPackage) external onlyOwner { require(newPackage.version > package.version, "Newer package already published"); packages[package.version] = package; package = newPackage; versions.push(package.version); emit NewPackage(package.version, block.timestamp); } function findPackageAtTimestamp (uint timestamp) external view returns (Package memory) { if (package.timestamp <= timestamp) { return package; } // the countdown loop to find the latest package for the timestamp int i = int(versions.length); while (--i > -1) { Package memory pkg = packages[versions[uint(i)]]; if (pkg.timestamp <= timestamp) { return pkg; } } revert("No package found"); } function getPackage (uint version) external view returns (Package memory) { if (version == package.version) { return package; } return packages[version]; } }

ყველა დეველოპერს შეუძლია წაიკითხოს და გაიგოს ეს კოდი მინიმალური ძალისხმევით. თუ თქვენ იცნობთ TypeScript-ს, აქ ცნებების უმეტესობას უკვე აზრი ექნება. კიდევ უფრო გასაგებად, მე შევქმენი ექვივალენტური TypeScript მაგალითი: AppVersionManager.ts 🔗 .

მარტივი სიტყვებით, კონტრაქტი Solidity-ში შეიძლება ჩაითვალოს როგორც სახელმწიფო კლასის ინსტანცია . თვისებების, მეთოდების, ტიპებისა და მემკვიდრეობის ცნებები უკვე ცნობილია ობიექტზე ორიენტირებულ პროგრამირებაში. აქ ასახსნელი მთავარი კონცეფცია არის onlyOwner მოდიფიკატორი (მსგავსი დეკორატორია TypeScript-ში).

ყველა ბლოკჩეინის ანგარიში არსებითად არის კერძო და საჯარო გასაღებების წყვილი. ანგარიშის ID, რომელიც ცნობილია როგორც მისამართი , მიღებულია საჯარო გასაღებიდან. როდესაც ტრანზაქცია შესრულდება, გამგზავნის მისამართი გადაეცემა როგორც msg.sender . ამის გამოყენებით, ჩვენ შეგვიძლია შევინახოთ თქვენი მისამართი კონსტრუქტორში (კონტრაქტის განლაგების დროს). მოგვიანებით, onlyOwner მოდიფიკატორი უზრუნველყოფს, რომ მხოლოდ თქვენ, როგორც კონტრაქტის მფლობელს, შეგიძლიათ განახორციელოთ updateInfo და updatePackage ფუნქციები. თუ ვინმე სხვა შეეცდება ამ ქმედებებს, ტრანზაქცია დაბრუნდება. onlyOwner მოდიფიკატორი მოწოდებულია Ownable კონტრაქტით, რომელიც ფართოდ გამოყენებული OpenZeppelin ბიბლიოთეკის ნაწილია. ეს ბიბლიოთეკა შეიცავს ბევრ სხვა სასარგებლო კონტრაქტს ბლოკჩეინის განვითარების გასამარტივებლად.

განსახილველი კიდევ ერთი მნიშვნელოვანი თემაა Proxies- ის კონცეფცია, რომელიც ყოფს შენახვას და განხორციელებას ორ ცალკეულ კონტრაქტად. Solidity-ში კონტრაქტის განხორციელება უცვლელია, რაც ნიშნავს, რომ თქვენ არ შეგიძლიათ დაამატოთ ახალი ფუნქციები ან თვისებები განლაგების შემდეგ. ამის გადასაჭრელად, შეგიძლიათ განათავსოთ „პროქსი“ ხელშეკრულება. პროქსი მართავს შენახვას და შეიცავს მხოლოდ ერთ fallback ფუნქციას, რომელიც გადასცემს ზარებს იმპლემენტაციის კონტრაქტზე, პროქსის შენახვის კონტექსტის შენარჩუნებით.

ეს კონცეფცია შეიძლება რთულად ჟღერდეს, მაგრამ მსგავსია, თუ როგორ მუშაობს this JavaScript-ში. აქ არის სწრაფი ანალოგია, რომელიც დაგეხმარებათ გარკვევაში:

 const foo = new Proxy({ bar: 'Lorem' }, { get (obj, prop) { return fooImplementation[prop].bind(obj) }, }); const fooImplementation = { logValue () { console.log('Bar value:', this.bar) } } foo.logValue();

მინდობილობის ხელშეკრულება შეიცავს მითითებას განხორციელების ხელშეკრულებაზე. თუ გსურთ ახალი ფუნქციების დამატება, თქვენ უბრალოდ განათავსეთ ახალი განხორციელების ხელშეკრულება და განაახლეთ პროქსი ამ ახალი კონტრაქტის მითითებისთვის, ფუნქციის ზარების გადამისამართება განახლებულ ინსტანციაზე. ეს მარტივი პროცესია, მაგრამ გასათვალისწინებელია უპირატესობა: კონსტრუქტორები.

განხორციელების ხელშეკრულების განლაგებისას, მისი კონსტრუქტორი მოქმედებს თავად განხორციელების ხელშეკრულების შენახვის ფარგლებში. ეს ნიშნავს, რომ სეტერები, როგორიცაა title = "Hello World" არ შეცვლიან პროქსის მეხსიერებას. ამის მოსაგვარებლად, ჩვენ ვიყენებთ ინიციალატორის ფუნქციის კონცეფციას:

1. განათავსეთ განხორციელების ხელშეკრულება initialize ფუნქციით.
2. განათავსეთ მარიონეტული ხელშეკრულება, მის კონსტრუქტორში განხორციელების ხელშეკრულების მისამართის გადაცემით. ეს დაყენება იძლევა initialize მეთოდის გამოძახებას პროქსი კონტრაქტის კონტექსტში.

შედეგად, title თვისების განახლება, მაგალითად, სწორად განაახლებს მას პროქსის საცავში.

აქ არის ჩვენი AppVersionManager-ის განხორციელების განახლებული ვერსია: AppVersionManagerUpgradeable.sol .

თავად მარიონეტული ხელშეკრულება საკმაოდ უნივერსალურია და განხორციელებისაგან დამოუკიდებელი. პროქსიების რამდენიმე ცნობილი სტანდარტი ხელმისაწვდომია OpenZeppelin ბიბლიოთეკაში.

ამ კონცეფციებისა და ზემოთ მოყვანილი მაგალითების ცოდნით, თქვენ მზად ხართ განავითაროთ ჭკვიანი კონტრაქტები თქვენი ბიზნეს საქმეებისთვის.

§ განლაგება

1. აირჩიეთ ბლოკჩეინი

პირველ რიგში, ჩვენ უნდა ავირჩიოთ ბლოკჩეინი, სადაც გვინდა გავავრცელოთ ჩვენი კონტრაქტი. ამ მაგალითისთვის მე ავირჩიე პოლიგონი. ის გთავაზობთ დაბალ ტრანზაქციის ხარჯებს, უკვე დიდი ხანია არსებობს და მუდმივად კარგად მუშაობს. მისი სტაბილური და ეფექტური ინფრასტრუქტურა, 0,9 მილიარდი დოლარის მთლიანი ღირებულების ჩაკეტვასთან ერთად, მას საიმედო არჩევანს აქცევს. თქვენი კონტრაქტების განთავსება საჯარო ბლოკჩეინებზე ნიშნავს ფინანსურ ინსტიტუტებთან თანაარსებობას. TVL მეტრიკა ასახავს ამ ინსტიტუტების ნდობას ბლოკჩეინის საიმედოობის მიმართ.

უფრო მეტიც, თუ პირობები შეიცვლება, თქვენ ყოველთვის შეგიძლიათ მომავალში გადაანაწილოთ კონტრაქტი სხვა ბლოკჩეინზე.

2. განლაგება

დემო პროექტი ასევე ემსახურება როგორც CI ტესტის საცავი, ამიტომ ყველა ბრძანება შეგიძლიათ იხილოთ აქ: https://github.com/0xweb-org/examples-backend/blob/master/deploy-cli.sh

 # Install 0xweb library from NPM into the prject folder npm i 0xweb # Install required dependencies to compile/deploy *.sol files npx 0xweb init --hardhat --openzeppelin # Create or import the account. Private key will be encrypted with pin AND machine key. npx 0xweb accounts new --name foo --pin test --login # Save the private key securly and ensure the account has some POL tokens # Deploy. The foo account is selected as default. npx 0xweb deploy ./contracts/AppVersionManager.sol --chain polygon --pin test # Set title npx 0xweb c write AppVersionManager updateInfo --newTitle MySuperApp --pin test # Set latest package information npx 0xweb c write AppVersionManager updatePackage --arg0 'load(./data/package.json)' --pin test

მხოლოდ რამდენიმე ბრძანებით, თქვენ განათავსეთ კონტრაქტი და განაახლეთ მონაცემები. ეს არის უკანა პლანზე - ის ახლა მუშაობს „სამუდამოდ“ თქვენი მხრიდან შემდგომი ქმედებების მოთხოვნის გარეშე. ამ განლაგების ხარჯები, გაზის ფასი 70 გვეი და POL ფასი 0,51 აშშ დოლარი, იქნება:

თქვენ ხარჯავთ მხოლოდ 4 ცენტს დეცენტრალიზებული , უსაფრთხო და გრძელვადიანი სერვისის დასაყენებლად, ტექნიკური მომსახურების გარეშე .

§ შეკითხვა

თქვენი კონტრაქტის მონაცემების გამოსაკითხად, დაგჭირდებათ RPC კვანძის პროვაიდერები. ათობით უფასო პროვაიდერი ხელმისაწვდომია https://chainlist.org- ზე. თქვენ შეგიძლიათ აირჩიოთ მრავალი პროვაიდერი, ხოლო კარგ Web3 ბიბლიოთეკას შეუძლია გამოიყენოს მრგვალი სტრატეგია გაშვების დროს, რათა აირჩიოთ ყველაზე ეფექტური თქვენი საბოლოო მომხმარებლებისთვის. 0xweb-ით, გენერირებული TypeScript ან JavaScript კლასები არა მხოლოდ ირჩევს საუკეთესო საბოლოო წერტილებს, არამედ აბსტრაქტებს ყველა ბლოკჩეინ კომუნიკაციას. კლიენტები შეიცავს მაღალი დონის მეთოდებს მონაცემების მისაღებად, რაც პროცესს უპრობლემოდ და ეფექტურს ხდის.

 # The deploy command also generates the class, but manual install is also possible npx 0xweb i 0x<address> --name AppVersionManager --chain polygon

 import { AppVersionManager } from './0xc/polygon/AppVersionManager/AppVersionManager' const manager = new AppVersionManager(); console.log(`Title`, await manager.title()); console.log(`Package`, await manager.package());

სხვა პროგრამირების ენებისთვის, უამრავი ბიბლიოთეკაა ხელმისაწვდომი ბლოკჩეინის შეკითხვის გასამარტივებლად. განლაგების შემდეგ, თქვენ გექნებათ კონტრაქტის მისამართი და ABI (ინტერფეისი).

ალტერნატიულად, შეგიძლიათ გაუშვათ შუაპროგრამის სერვერი კონტრაქტის მონაცემების შეკითხვისთვის 0xweb-ის გამოყენებით.

 npx 0xweb server start --port 3000 curl http://localhost:3000/api/c/read/AppVersionManager/package?chain=polygon

ერთი უპირატესობა ის არის, რომ თქვენ არ გჭირდებათ რაიმე ბიბლიოთეკის ჩართვა თქვენს აპლიკაციაში - დაუმუშავებელი HTTP მოთხოვნები. თუმცა, ეს მიდგომა ეყრდნობა დამატებით სერვერს, რომლის მართვაც დაგჭირდებათ. ხშირად ჯობია ბლოკჩეინზე უშუალოდ შეკითხვა 0xweb-ის მიერ გენერირებული კლასების ან ხელმისაწვდომი ბლოკჩეინის სხვა ბიბლიოთეკების გამოყენებით.

§ რეზიუმე 🏁

ამ სტატიამ აჩვენა, თუ როგორ შეიძლება იყოს ბლოკჩეინი მარტივი და ძლიერი, რაც უნიკალურ უპირატესობებს გვთავაზობს ტრადიციულ ჰოსტინგის გადაწყვეტილებებთან შედარებით.

შემდეგ სტატიაში მე ვაპირებ შევისწავლო BLOB-ის დეცენტრალიზებული საცავის ქსელები, როგორიცაა Greenfield და Arweave, ხაზს ვუსვამ მათ მახასიათებლებსა და უპირატესობებს.

თუ თქვენ გაქვთ რაიმე წინადადება ან იდეა დამატებითი ფუნქციების ჩასართავად 0xweb ბიბლიოთეკაში, მოგერიდებათ გააზიაროთ ისინი კომენტარებში ან დაუკავშირდით პირდაპირ [email protected] .