initial commit

Git bash.txt

@@ -0,0 +1,17 @@
+Команды для Git bash
+
+1) git status
+
+2) git add .
+
+3) git status
+
+4) git commit -m "gg"
+
+5) git config --global user.email ""
+
+6) git config --global user.email "user39" // Свой логин
+
+7) git commit -m "gg"
+
+8) git push -u origin master

Гит баш.txt

@@ -0,0 +1,7 @@
+git init
+git add .
+git commit -m "initial commit"
+git remote add origin ---- ссылка 
+git push -u origin master
+
+https://try.gogs.io/

Код Солидити 4 магазина Ильи.txt

@@ -0,0 +1,343 @@
+ //SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.7.0 <0.9.0;
+pragma experimental ABIEncoderV2;
+contract SmartContract {
+    enum Roles {
+		administrator, seller, customer
+	}
+
+    struct User {
+		bytes32 password;
+		uint balance;
+		Roles role;
+		bool isExist;
+	}
+
+	struct Product {
+		string name;
+		uint price;
+		uint count;
+	}
+
+    struct Shop
+    {
+        string NameShop;
+        address[] Sellers;
+        //Product[] Products;
+        mapping(uint => Product) Products;
+        uint count;
+    }
+
+	struct Request {
+		string name;
+		uint price;
+	}
+
+	mapping (address => Request) afasf;
+    mapping(uint => Shop) private shops;
+    string[] public shopList;
+	mapping(address => User) private users;
+    address[] reg;
+
+
+	struct Event{
+		address user;
+		uint8 eventType;
+		bool isComplet;
+	}
+
+    struct BuyEvent{
+		address user;
+		uint8 eventType;
+		bool isComplet;
+        uint shop;
+        uint productNumber;
+        uint price;
+        bool refund;
+	}
+
+	modifier only_admin { require(users[msg.sender].role == Roles.administrator); _; }
+	modifier only_seller { require(users[msg.sender].role == Roles.seller); _; }
+
+	Event[] public adminsEvents;
+	BuyEvent[] public sellerEvents;
+
+	//запрос на повышение или понижение
+	function eventChangeRole()
+		public
+	{
+		require(users[msg.sender].role != Roles.administrator, "it's seller and buyer functions");
+		if(users[msg.sender].role == Roles.seller){
+			adminsEvents.push(Event(msg.sender,2,false));
+		}
+		if(users[msg.sender].role == Roles.customer){
+			adminsEvents.push(Event(msg.sender,1,false));
+		}
+	}
+
+	function ChangeRoleAllEvents() only_admin
+		public returns (uint)
+	{
+		for(uint i = adminsEvents.length-1;i>=0;i--){
+			if(adminsEvents[i].isComplet != true){
+				if(adminsEvents[i].eventType == 1)
+					updateRole(adminsEvents[i].user,Roles.seller);
+				else
+					updateRole(adminsEvents[i].user,Roles.customer);
+			}
+			remove(i-1);
+			//adminsEvents.pop();
+			// if(adminsEvents.length>1)
+			// 	adminsEvents.pop();
+			// else delete adminsEvents[i];
+		}
+		return adminsEvents.length;
+	}
+
+	function remove(uint _index) private {
+        require(_index < adminsEvents.length, "index out of bound");
+
+        for (uint i = _index; i < adminsEvents.length - 1; i++) {
+            adminsEvents[i] = adminsEvents[i + 1];
+        }
+        adminsEvents.pop();
+    }
+
+
+
+
+
+    /*constructor() public {
+        //address public owner = msg.sender;
+    	registrateAdmin(0x5B38Da6a701c568545dCfcB03FcB875f56beddC4, "admin", 0);
+        registrateAdmin(0xAb8483F64d9C6d1EcF9b849Ae677dD3315835cb2, "seller", 0);
+        updateRole(0xAb8483F64d9C6d1EcF9b849Ae677dD3315835cb2, Roles.seller);
+        registrateAdmin(0x4B20993Bc481177ec7E8f571ceCaE8A9e22C02db, "customer", 0);
+        updateRole(0x4B20993Bc481177ec7E8f571ceCaE8A9e22C02db, Roles.customer);
+	}*/
+    function addShop(string memory NameShop) public returns (string[] memory)
+	{
+        shops[shopList.length].NameShop;
+        shopList.push(NameShop);
+        return shopList;
+    }
+
+    function add_sellerToShop(address seller) public returns(address[] memory){
+        shops[shopList.length].Sellers.push(seller);
+        return shops[shopList.length].Sellers;
+    }
+
+    constructor() {
+        //address public owner = msg.sender;
+        registrateNewUser(msg.sender, Roles.administrator,"admin",1000);
+    	registrateNewUser(0xd8c33DC6aa71dc5dF0Cb2638bD889D33C92eeF5c, Roles.seller,"seller",1000);
+        registrateNewUser(0xE2b9B07a218262fc55439F60320FdDa9692086A1, Roles.customer,"customer",1000);
+
+        addShop("Petyorochka");
+        pushNewProduct(0,"apple",100,2);
+        pushNewProduct(0,"pear",90,3);
+        pushNewProduct(0,"peach",80,4);
+        pushNewProduct(0,"nectarine",70,1);
+        pushNewProduct(0,"kiwi",120,2);
+
+        addShop("Garden");
+        pushNewProduct(1,"apple_juice",100,2);
+        pushNewProduct(1,"pear_juice",90,3);
+        pushNewProduct(1,"peach_juice",80,4);
+        pushNewProduct(1,"nectarine_juice",70,1);
+        pushNewProduct(1,"kiwi_juice",120,2);
+
+		// Product[] memory d;
+		// d = pr;
+		// shops2.push(Shop(pr,1));
+			/*
+		shops2.push(Shop({
+                product: d,
+                count: 1
+            }));*/
+
+	}
+
+	function pushNewProduct(
+		uint _shopNum,
+		string memory _name,
+		uint _price,
+		uint _count)
+		public
+	{
+		//string s1, s2, s3; s3 = bytes.concat(bytes(s1), bytes(s2));
+		//require(users[msg.sender].isExist == false, "Users already exist");
+        uint count = shops[_shopNum].count;
+		shops[_shopNum].Products[count] = Product(_name,_price,_count);
+		shops[_shopNum].count++;
+	}
+
+	function productList(uint _shopNum) public view returns(Product[] memory)
+	{
+        uint count = shops[_shopNum].count;
+		require(count > 0, "List of products are empty");
+		Product[] memory list = new Product[](count);
+        for(uint i = 0; i < count; i++){
+            list[i] = (shops[_shopNum].Products[i]);
+        }
+		return list;
+	}
+	function lastProductInList(uint _shopNum) public view returns(Product memory)
+	{
+        uint count = shops[_shopNum].count;
+		require(count > 0, "List of products are empty");
+		return shops[_shopNum].Products[count-1];
+	}
+
+	function registrateNewUser(address _adr, Roles role,
+		string memory _password,
+		uint _balance)
+		public
+	{
+		require(users[_adr].isExist == false, "Users already exist");
+		users[_adr] = User(
+			keccak256(abi.encodePacked(_password)),
+			_balance,
+			role,
+			true
+		);
+        reg.push(_adr);
+	}
+
+	function authInSystem(
+		string memory _password
+		) public view returns(bool)
+	{
+		require(users[msg.sender].isExist == true, "User doesn't register");
+		//return keccak256(abi.encodePacked(_password)) == keccak256(abi.encodePacked(users[msg.sender].password));
+		return keccak256(abi.encodePacked(_password)) == users[msg.sender].password;
+	}
+
+    function updateRole(address _address, Roles role) only_admin public
+    {
+        users[_address].role = role;
+    }
+
+
+    //dataget
+    function getMeData() public view returns(
+		bytes32 _password,
+		uint _balance,
+		Roles _role,
+		bool _isExist)
+	{
+		require(users[msg.sender].isExist == true, "User not exist");
+		_password = users[msg.sender].password;
+		_balance = users[msg.sender].balance;
+		_role = users[msg.sender].role;
+		_isExist = users[msg.sender].isExist;
+	}
+	function getUserData(address _addressUser) public view returns (
+		bytes32 _password,
+		uint _balance,
+		Roles _role,
+		bool _isExist)
+	{
+		require(users[_addressUser].isExist == true, "User not exist");
+		_password = users[_addressUser].password;
+		_balance = users[_addressUser].balance;
+		_role = users[_addressUser].role;
+		_isExist = users[_addressUser].isExist;
+	}
+
+    function getSellerData(address _addressUser) public view returns (
+		bytes32 _password,
+		uint _balance,
+		Roles _role,
+		bool _isExist)
+	{
+		require(users[_addressUser].isExist == true, "User not exist");
+        require(users[_addressUser].role == Roles.seller, "User not a seller");
+		_password = users[_addressUser].password;
+		_balance = users[_addressUser].balance;
+		_role = users[_addressUser].role;
+		_isExist = users[_addressUser].isExist;
+	}
+
+
+    //buyer
+    function buyProduct(uint shop,  uint productNumber, uint count)
+	public
+	{
+
+        require(count > 0,"count is not more then 0");
+        if(shop==1){
+            shops;
+        }
+		uint productPrice = shops[shop].Products[productNumber].price;
+        require(productPrice * count < users[msg.sender].balance,"account balance not enought");
+		users[msg.sender].balance -= shops[shop].Products[productNumber].price * count;
+		//(_firstName,_lastName,balance) = getMyData();
+	}
+
+    /*
+    Может подтверждать или отклонять запрос покупателя на покупку, возврат товара, оформление брака.
+        struct BuyEvent{
+		address user;
+		uint8 eventType;
+		bool isComplet;
+        uint8 shop;
+        uint8 productNumber;
+        uint8 count;
+        bool refund;
+	}
+    event UserWantBuyProduct(addres addr, uint8 shop, uint8 productNumber);
+    //Продавец подтвердил покупку товара
+    event UserBuyPtoduct_seller(adress _seller, address _byuer, uint8 shop, uint8 productNumber, uint8 price);
+    */
+    function buyProductEvent(uint shop,  uint productNumber, uint count)
+	public
+	{
+        require(count > 0,"count is not more then 0");
+		uint productPrice = shops[shop].Products[productNumber].price;
+        require(productPrice * count < users[msg.sender].balance,"account balance not enought");
+		sellerEvents.push(BuyEvent(msg.sender,4,false,shop,productNumber,productPrice,false));
+	}
+
+    function confirmBuy(uint eventId) only_seller payable public
+    {
+        require(sellerEvents[eventId].isComplet == false, "this purchase is complet");
+        require(sellerEvents[eventId].price < users[sellerEvents[eventId].user].balance,"account balance not enought");
+        users[sellerEvents[eventId].user].balance -= sellerEvents[eventId].price;
+		sellerEvents[eventId].isComplet = true;
+    }
+	event UserWantRefudProduct(address addr, uint shop, uint productNumber, uint position);
+
+	function refundProductEvent(uint shop,  uint productNumber)
+	public
+	{
+		for(uint i = 0;i<sellerEvents.length;i++){
+			    if(sellerEvents[i].isComplet == true && sellerEvents[i].user == msg.sender && sellerEvents[i].refund == false){
+                    if(sellerEvents[i].shop == shop && sellerEvents[i].productNumber == productNumber){
+				        //сделать запрос на возврат
+                    }
+			    }
+        }
+
+	}
+    function confirmRefund(uint eventId) only_seller payable public
+    {
+        require(sellerEvents[eventId].isComplet == true, "this purchase is not complet");
+        require(sellerEvents[eventId].refund == false, "this refund is complite");
+        users[sellerEvents[eventId].user].balance += sellerEvents[eventId].price;
+		sellerEvents[eventId].refund = true;
+    }
+
+    function cancleBuy(uint shop,  uint productNumber) payable public
+    {
+        for(uint i = 0;i<sellerEvents.length;i++){
+			    if(sellerEvents[i].isComplet == false && sellerEvents[i].user == msg.sender){
+                    if(sellerEvents[i].shop == shop && sellerEvents[i].productNumber == productNumber){
+				        delete sellerEvents[i];
+
+                    }
+			    }
+        }
+    }
+
+}

Код Солидити 4 магазина.txt

@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity >=0.7.0 <0.9.0;
+
+contract StoreQual{
+    struct User{
+        string Name;
+        bytes32 PasswordHash;
+        uint Balance;
+        uint Role; // 0 - Админ, 1 - Продавец, 2 - Покупатель
+        bool isUserExist;
+    }
+    mapping(address => User) public users;
+    mapping(string => uint) public products;
+    string[] productNames;
+
+    constructor() {
+        users[0x9aD3228b53F43f33AcB1bBBab8Bb479B5e8256DB] = User("Admin", keccak256(abi.encodePacked("qwe")), 1000, 0, true);
+        users[0x918b93A13199851221DDA57Aa2Fc3df0651F7490] = User("Seller", keccak256(abi.encodePacked("asd")), 1000, 1, true);
+        users[0x4409DDa3fE79646e15b67a1602BD7B6C8E1F66A7] = User("Buyer", keccak256(abi.encodePacked("zxc")), 1000, 2, true);
+    }
+
+    // Авторизация
+    function AuthUser(string memory Password) public view returns(bool) {
+        require(users[msg.sender].isUserExist == true, "User not exist");
+
+        if (users[msg.sender].PasswordHash == keccak256(abi.encodePacked(Password))) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    // Регистрация
+    function RegUser(string memory Name, string memory Password) public {
+        require(users[msg.sender].isUserExist == false, "User already exist");
+
+        users[msg.sender] = (User(Name, keccak256(abi.encodePacked(Password)), 100, 0, true));
+    }
+
+    function GetProducts() public view returns(string[] memory) {
+        return productNames;
+    }
+
+    function ViewBalance() public view returns(uint) {
+        return users[msg.sender].Balance;
+    }
+
+    // Функции админа
+    modifier onlyAdmin {
+        require(users[msg.sender].Role == 0);
+        _;
+    }
+
+    // Повышение до админа
+    function PromotionToAdmin(address addressUser) public onlyAdmin{
+        require(users[addressUser].isUserExist == true, "User not exist");
+
+        users[addressUser].Role = 0;
+    }
+
+    // Роль = продавец
+    function PromotionToSeller(address addressUser) public onlyAdmin{
+        require(users[addressUser].isUserExist == true, "User not exist");
+        require(users[addressUser].Role != 0, "User is Admin");
+
+        users[addressUser].Role = 1;
+    }
+
+    // Роль = покупатель
+    function DemotionSellerToBuyer(address addressUser) public view onlyAdmin{
+        require(users[addressUser].isUserExist == true, "User not exist");
+        require(users[addressUser].Role == 1, "User not Seller");
+
+        users[addressUser].Role == 2;
+    }
+    
+    // Функция продавца 
+    modifier onlySeller {
+        require(users[msg.sender].Role == 1);
+        _;
+    } 
+
+    // Создание продукта
+    function AddNewProduct(string memory Name, uint Price) public onlySeller {
+        require(products[Name] == 0, "Product is exist");
+        require(Price > 0, "The price cannot be less than 0");
+
+        products[Name] = Price;
+        productNames.push(Name);
+    }
+
+    // Редактирование продукта
+    function EditProduct(string memory Name, uint Price) public onlySeller {
+        require(products[Name] != 0, "Product not exist");
+        require(Price > 0, "The price cannot be less than 0");
+
+        products[Name] = Price;
+    }
+    // Buyer Func
+    modifier onlyBuyer {
+        require(users[msg.sender].Role == 2);
+        _;
+    }
+
+    // Покупка товара
+    function BuyProduct(string memory Name) public onlyBuyer {
+        require(products[Name] != 0, "Product not exist");
+        require(products[Name] <= users[msg.sender].Balance, "No money");
+
+        users[msg.sender].Balance -= products[Name];
+    }
+}

Код Срез 2.txt

@@ -0,0 +1,172 @@
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity >=0.7.0 <0.9.0;
+
+contract ShopContract
+{
+    // Структура пользователя 
+    struct User
+    {
+        string Name;
+        bytes32 PasswordHash;
+        //uint Balance;
+        uint Role; // 0 - Админ, 1 - Продавец, 2 - Покупатель
+        bool isUserExist;
+    }
+
+    // Структура заявки на смеу роли 
+    struct Request
+    {
+        address Address;
+        uint Role;
+    }
+
+    // Структура магазина
+    struct Shop
+    {
+        address AddrShop;
+        string Name;
+        uint Balance;
+        bool isShopExist;
+    }
+
+    // Структура отзывов
+    struct Review
+    {
+        address AddrUser;
+        address AddrShop;
+        uint Grade;
+        string Comments; 
+    }
+
+    // Структура заяви комментариев 
+    struct RequestComments
+    {
+        address Address;
+        uint Role;
+    }
+
+    Request[] Requests;
+
+    RequestComments[] RequestCommentss;
+
+    Review[] Reviews;
+
+    mapping(address => User) public users;
+    mapping(address => Shop) public shops;
+
+    constructor() 
+    {
+        //shops[0x14723A09ACff6D2A60DcdF7aA4AFf308FDDC160C] = Shop("DNSS", 100, true);
+        users[0x5B38Da6a701c568545dCfcB03FcB875f56beddC4] = User("Admin", keccak256(abi.encodePacked("0000")), 0, true);
+        users[0xAb8483F64d9C6d1EcF9b849Ae677dD3315835cb2] = User("Seller", keccak256(abi.encodePacked("1111")), 1, true);
+        users[0x4B20993Bc481177ec7E8f571ceCaE8A9e22C02db] = User("Buyer", keccak256(abi.encodePacked("2222")), 2, true);
+    }
+
+    // Авторизация
+    function AuthUser(string memory Password) public view returns(bool) 
+    {
+        require(users[msg.sender].isUserExist == true, "User not exist");
+
+        if (users[msg.sender].PasswordHash == keccak256(abi.encodePacked(Password))) 
+        {
+            return true;
+        } 
+        else 
+        {
+            return false;
+        }
+    }
+
+    // Регистрация
+    function RegUser(string memory Name, string memory Password) public 
+    {
+        require(users[msg.sender].isUserExist == false, "User already exist");
+
+        users[msg.sender] = (User(Name, keccak256(abi.encodePacked(Password)), 2, true));
+    }
+
+    // Добавление магазина
+    function AddShop(address addrshop, string memory Name, uint Balance) public 
+    {
+        require(shops[msg.sender].isShopExist == false, "Shop already exist");
+        shops[msg.sender] = (Shop(addrshop, Name, Balance, true));
+    }
+
+    // Функции админа
+    modifier onlyAdmin 
+    {
+        require(users[msg.sender].Role == 0);
+        _;
+    }
+
+    // Повышает обычного покупателя до роли продавец
+    function PromotionToSeller(address addressUser) public onlyAdmin
+    {
+        require(users[addressUser].isUserExist == true, "User not exist");
+        require(users[msg.sender].Role == 0, "You are not a Admin");
+        require(users[addressUser].Role == 2, "User not Buyer");
+
+        users[addressUser].Role = 1;
+    }
+
+    // Понижает продавца до роли покупатель
+    function DemotionSellerToBuyer(address addressUser) public view onlyAdmin
+    {
+        require(users[addressUser].isUserExist == true, "User not exist");
+        require(users[msg.sender].Role == 0, "You are not a Admin");
+        require(users[addressUser].Role == 1, "User not Seller");
+
+        users[addressUser].Role == 2;
+    }
+    
+    // Может переключиться к роли покупатель
+    function RoleBuyer() public view onlyAdmin
+    {
+        require(users[msg.sender].isUserExist == true, "User not exist");
+        require(users[msg.sender].Role == 0, "You are not a Admin");
+
+        users[msg.sender].Role == 2;
+    }
+
+    // Новые администраторы КПРФ
+    function NewAdmin(address addr) public
+    {
+        require(users[msg.sender].Role == 0, "You are not a admin");
+        users[addr].Role = 0;
+    }
+
+    function DeleteShop(address addr) public view
+    {
+        require(shops[addr].isShopExist == false, "You are not a shop");
+        shops[addr].isShopExist == false;
+    }
+
+    // Функции продавца
+    function RoleSellerDown() public view
+    {
+        require(users[msg.sender].isUserExist == true, "User not exist");
+        require(users[msg.sender].Role == 1, "You are not a Salesmen");
+
+        users[msg.sender].Role == 2;
+    }
+
+    function RequestRoleSellerDown() public 
+    {
+        require(users[msg.sender].Role == 3, "You are not a seller");
+        Requests.push(Request(msg.sender, 2));
+    }
+
+    function SellerComments(address addrShop, uint grade, string memory comments) public
+    {
+        // address AddrUser;
+        // address AddrShop;
+        // uint Grade;
+        // string Comments; 
+
+        require(users[msg.sender].Role != 0, "You are not a seller and not a buyer");
+        Reviews.push(Review(msg.sender, addrShop, grade, comments));
+    }
+
+    
+}

Код для подключения.txt

@@ -0,0 +1,221 @@
+current_user_address = ''
+current_user_data = ''
+
+contract_address = '0x8b1459c586B6a5A30C7A5b057377A878B8De70D0'
+
+contract_abi = [
+	{
+		"inputs": [],
+		"stateMutability": "nonpayable",
+		"type": "constructor"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "string",
+				"name": "Name",
+				"type": "string"
+			},
+			{
+				"internalType": "uint256",
+				"name": "Price",
+				"type": "uint256"
+			}
+		],
+		"name": "AddNewProduct",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "string",
+				"name": "Password",
+				"type": "string"
+			}
+		],
+		"name": "AuthUser",
+		"outputs": [
+			{
+				"internalType": "bool",
+				"name": "",
+				"type": "bool"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "string",
+				"name": "Name",
+				"type": "string"
+			}
+		],
+		"name": "BuyProduct",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "address",
+				"name": "addressUser",
+				"type": "address"
+			}
+		],
+		"name": "DemotionSellerToBuyer",
+		"outputs": [],
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "string",
+				"name": "Name",
+				"type": "string"
+			},
+			{
+				"internalType": "uint256",
+				"name": "Price",
+				"type": "uint256"
+			}
+		],
+		"name": "EditProduct",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"name": "GetProducts",
+		"outputs": [
+			{
+				"internalType": "string[]",
+				"name": "",
+				"type": "string[]"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "address",
+				"name": "addressUser",
+				"type": "address"
+			}
+		],
+		"name": "PromotionToAdmin",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "address",
+				"name": "addressUser",
+				"type": "address"
+			}
+		],
+		"name": "PromotionToSeller",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "string",
+				"name": "Name",
+				"type": "string"
+			},
+			{
+				"internalType": "string",
+				"name": "Password",
+				"type": "string"
+			}
+		],
+		"name": "RegUser",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"name": "ViewBalance",
+		"outputs": [
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "string",
+				"name": "",
+				"type": "string"
+			}
+		],
+		"name": "products",
+		"outputs": [
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "address",
+				"name": "",
+				"type": "address"
+			}
+		],
+		"name": "users",
+		"outputs": [
+			{
+				"internalType": "string",
+				"name": "Name",
+				"type": "string"
+			},
+			{
+				"internalType": "bytes32",
+				"name": "PasswordHash",
+				"type": "bytes32"
+			},
+			{
+				"internalType": "uint256",
+				"name": "Balance",
+				"type": "uint256"
+			},
+			{
+				"internalType": "uint256",
+				"name": "Role",
+				"type": "uint256"
+			},
+			{
+				"internalType": "bool",
+				"name": "isUserExist",
+				"type": "bool"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	}
+]

Код интерфейса.txt

@@ -0,0 +1,169 @@
+import web3.exceptions
+from web3 import Web3
+import service
+
+#
+w3 = Web3(Web3.HTTPProvider('http://127.0.0.1:7545'))
+store_contract = w3.eth.contract(address=service.contract_address,
+                                 abi=service.contract_abi)
+
+
+def auth():
+    print('Введите адрес:')
+    address = input()
+    print('Введите пароль:')
+    password = input()
+
+    if address != '' and password != '':
+        try:
+            auth_user = store_contract.functions.AuthUser(password).call({'from': address})
+            if auth_user:
+                print('Вы авторизованы')
+                service.current_user_address = address
+                service.current_user_data = store_contract.functions.users(service.current_user_address).call()
+                if service.current_user_data[3] == 0:
+                    admin_menu()
+                elif service.current_user_data[3] == 1:
+                    seller_menu()
+                elif service.current_user_data[3] == 2:
+                    buyer_menu()
+            else:
+                print('Вы не авторизованы')
+                return
+        except web3.exceptions.ContractLogicError as err:
+            print(err)
+
+
+def reg():
+    print("Введите адрес: ")
+    address = input()
+    print('Введите имя: ')
+    name = input()
+    print('Введите пароль: ')
+    password = input()
+    if address != '' and password != '' and name != '':
+        try:
+            store_contract.functions.RegUser(name, password).transact({'from': address})
+        except web3.exceptions.ContractLogicError as err:
+            print(err)
+
+
+def admin_menu():
+    while True:
+        print(" ")
+        print("Главное меню")
+        print("1 - Узнать баланс")
+        print("2 - Повысить пользователя")
+        print("3 - Повысить до продавца")
+        print("4 - Понизить продавца до покупателя")
+        print("0 - Закрыть")
+
+        user_choice = int(input())
+        if user_choice == 1:
+            print(store_contract.functions.ViewBalance().call({'from': service.current_user_address}))
+        elif user_choice == 2:
+            print('Введите адрес: ')
+            address = input()
+            try:
+                store_contract.functions.PromotionToAdmin(address).transact({'from': service.current_user_address})
+            except web3.exceptions.ContractLogicError as err:
+                print(err)
+        elif user_choice == 3:
+            print('Введите адрес: ')
+            address = input()
+            try:
+                store_contract.functions.PromotionToSeller(address).transact({'from': service.current_user_address})
+            except web3.exceptions.ContractLogicError as err:
+                print(err)
+        elif user_choice == 4:
+            print('Введите адрес: ')
+            address = input()
+            try:
+                store_contract.functions.DemotionSellerToBuyer(address).transact({'from': service.current_user_address})
+            except web3.exceptions.ContractLogicError as err:
+                print(err)
+        elif user_choice == 0:
+            break
+        else:
+            break
+
+
+def seller_menu():
+    while True:
+        print("Главное меню продавца")
+        print("1 - Добавление товара")
+        print("2 - Редактирование товара")
+        print("3 - Узнать баланс")
+        print("4 - Список товаров")
+        print("0 - Закрыть")
+
+        user_choice = int(input())
+        if user_choice == 1:
+            print('Введите название товара: ')
+            Name = input()
+            print('Введите цену товара: ')
+            Price = int(input())
+            try:
+                store_contract.functions.AddNewProduct(Name, Price).transact({'from': service.current_user_address})
+            except web3.exceptions.ContractLogicError as err:
+                print(err)
+        elif user_choice == 2:
+            print('Введите название товара: ')
+            Name = input()
+            print('Введите цену товара: ')
+            Price = int(input())
+            try:
+                store_contract.functions.EditProduct(Name, Price).transact({'from': service.current_user_address})
+            except web3.exceptions.ContractLogicError as err:
+                print(err)
+        elif user_choice == 3:
+                print(store_contract.functions.ViewBalance().call({'from': service.current_user_address}))
+        elif user_choice == 4:
+                print(store_contract.functions.GetProducts().call({'from': service.current_user_address}))
+        elif user_choice == 0:
+            break
+        else:
+            break
+
+
+def buyer_menu():
+    while True:
+        print("Главное меню покупателя")
+        print("1 - Покупка товаров")
+        print("2 - Узнать баланс")
+        print("3 - Список товаров")
+        print("0 - Закрыть")
+
+        user_choice = int(input())
+        if user_choice == 1:
+            print('Введите название товара/подукта: ')
+            NameProduct = input()
+            try:
+                store_contract.functions.BuyProduct(NameProduct).transact({'from': service.current_user_address})
+            except web3.exceptions.ContractLogicError as err:
+                print(err)
+        elif user_choice == 2:
+                print(store_contract.functions.ViewBalance().call({'from': service.current_user_address}))
+        elif user_choice == 3:
+                print(store_contract.functions.GetProducts().call({'from': service.current_user_address}))
+        elif user_choice == 0:
+            break
+        else:
+            break
+
+
+while True:
+    print("Привет!")
+    print("1 - Авторизация")
+    print("2 - Регистрация")
+    print("0 - Закрыть")
+    user_choice = int(input())
+
+    if user_choice == 1:
+        auth()
+    elif user_choice == 2:
+        reg()
+    elif user_choice == 0:
+        break
+    else:
+        break

Перевод между адресам Гит хаб.txt

@@ -0,0 +1,363 @@
+//SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.9;
+
+contract Ledger {
+    // Структура перевода
+    struct Transfer {
+        address payable to; // Кому осуществляем перевод
+        address payable from; // От кого осуществляется перевод
+        bytes32 codewordHash; // Хеш кодового слова, задается на клиенте по алгоритму keccak256
+        uint256 timestamp; // Дата создания перевода
+        uint256 value; // Количество веев в переводе
+        string description; // Описание перевода
+        bool success; // Были ли средства переведены получателю
+        bool done; // Был ли перевод завершен (значит, с переводом больше сделать ничего нельзя)
+    }
+
+    // Структура категории
+    struct Category {
+        string name; // Имя категории
+    }
+
+    // Структура шаблона
+    struct Template {
+        string name; // Название шаблона
+        uint256 categoryID; // Идентификатор категории
+        uint256[] values; // Возможные значения для перевода
+    }
+
+    // Структура пользователя
+    struct User {
+        bytes32 pwHash; // Хеш пароля, задается на клиенте
+        bool admin; // Администратор ли этот пользователь
+        uint256[] sentTransfers; // Отправленные переводы
+        uint256[] recievedTransfers; // Полученные переводы
+    }
+
+    // Структура голосования за повышения пользователя до уровня администратора
+    struct UserUpgradePoll {
+        address payable user;
+        address payable[] adminsApproved;
+    }
+
+    mapping(address => User) users; // пользователи по адресам в блокчейне
+    mapping(address => UserUpgradePoll) userUpgradePolls; // голосования за повышение пользователя до уровня администратора
+    address[] userUpgradePollsAddresses;
+
+    mapping(uint256 => Transfer) transfers; // переводы
+
+    mapping(string => Category) categories; // категории по названиям
+    mapping(string => Template) templates; // шаблоны по названиям
+
+    string[] categoryNames; // имена категорий, индексы соответсвуют ID
+    string[] templateNames; // имена шаблонов, индексы соответсвуют ID
+
+    uint256 numTransfers; // общее количество переводов
+    uint256 numAdmins; // общее количество администраторов
+
+    constructor() {
+        uint256[] memory defArray;
+        bytes32 defaultPasswordHash = keccak256(abi.encodePacked("123"));
+
+        // Users
+        users[0xd3d512f5D54cAB705962b8F5B18887FeA0cEdc09] = User(
+            defaultPasswordHash,
+            false,
+            defArray,
+            defArray
+        );
+        users[0xFF164757CDAeB859Ea01B793Eb5eEA1e30b80c06] = User(
+            defaultPasswordHash,
+            false,
+            defArray,
+            defArray
+        );
+        users[0xBc3E4436595F40c7eC699d79cB7B5ef26fEc68fA] = User(
+            defaultPasswordHash,
+            false,
+            defArray,
+            defArray
+        );
+        users[0xc46a163cB71A6E0ab221fbE68Ecfb11B3b79b8f5] = User(
+            defaultPasswordHash,
+            false,
+            defArray,
+            defArray
+        );
+
+        // Admins
+        users[0x56d8C3c6E4815d10Daa12466B1c8D77C5DDaA2b6] = User(
+            defaultPasswordHash,
+            true,
+            defArray,
+            defArray
+        );
+
+        users[0xafB6cEE6479737EA310C24FBc00e0D71C8BecF8d] = User(
+            defaultPasswordHash,
+            true,
+            defArray,
+            defArray
+        );
+    }
+
+    // Проверяет, администратор ли пользователь
+    modifier onlyAdmin() {
+        require(
+            users[msg.sender].admin,
+            "You're not permitted to do such operation!"
+        );
+        _;
+    }
+
+    // Создать перевод
+    function transfer(
+        address payable to,
+        bytes32 codewordHash,
+        string memory description
+    ) public payable returns (uint256 transferID) {
+        require(msg.value > 0, "You can't send zero coins!");
+
+        transferID = numTransfers++;
+
+        Transfer memory newTransfer = Transfer(
+            to,
+            payable(msg.sender),
+            codewordHash,
+            block.timestamp,
+            msg.value,
+            description,
+            false,
+            false
+        );
+        transfers[transferID] = newTransfer;
+
+        users[to].recievedTransfers.push(transferID);
+        users[msg.sender].sentTransfers.push(transferID);
+    }
+
+    // Подтвердить перевод (получатель пишет кодовое слово и если оно верно - получает деньги)
+    function verifyTransfer(uint256 transferID, bytes32 codewordHash)
+        public
+        returns (bool success)
+    {
+        Transfer memory thisTransfer = transfers[transferID];
+
+        // Если перевод завершен или предназначен не отправителю запроса, возвращаем ошибку
+        require(
+            msg.sender == thisTransfer.to && !thisTransfer.done,
+            "You can't verify this transfer!"
+        );
+
+        // Проверка кодового слова
+        require(codewordHash == thisTransfer.codewordHash, "Wrong codeword!");
+
+        // Адрес получателя
+        address payable recipient = payable(msg.sender);
+
+        // Указываем, что перевод успешно осуществлен и завершен
+        transfers[transferID].success = true;
+        transfers[transferID].done = true;
+        success = true;
+
+        // Переводим деньги получателю
+        recipient.transfer(thisTransfer.value);
+    }
+
+    // Отменить перевод, если он еще не осуществлен
+    function revertTransfer(uint256 transferID) public {
+        Transfer memory thisTransfer = transfers[transferID];
+
+        require(
+            msg.sender == thisTransfer.from,
+            "You can't revert this transfer!"
+        );
+        require(!thisTransfer.success, "This transfer is already done!");
+
+        address payable sender = payable(msg.sender);
+        sender.transfer(thisTransfer.value);
+
+        // Указываем, что перевод завершен (все остальные операции недоступны)
+        transfers[transferID].done = true;
+    }
+
+    // Получить список переводов за последние daysCount дней
+    function getTransfersOnDays(uint256 daysCount)
+        public
+        view
+        returns (Transfer[] memory allTransfersOnPeriod)
+    {
+        // Начиная с какого тамйштампа брать переводы: текущее время - (количество дней * 24 часа * 60 минут * 60 секунд)
+        uint256 fromTimestamp = block.timestamp -
+            (daysCount * 24 * 60 * 60 * 60);
+
+        // Отправленные и полученные переводы
+        uint256[] memory sentTransfers = users[msg.sender].sentTransfers;
+        uint256[] memory recievedTransfers = users[msg.sender]
+            .recievedTransfers;
+
+        uint256[][2] memory allTransfers = [sentTransfers, recievedTransfers];
+
+        uint256 lastIndex = 0;
+
+        // Проходимся по всем переводам, ищем те что нужно
+        for (uint8 i = 0; i < allTransfers.length; i++) {
+            for (uint256 j = 0; j < allTransfers[i].length; j++) {
+                uint256 thisTransferID = allTransfers[i][j];
+                Transfer memory thisTransfer = transfers[thisTransferID];
+
+                // Если перевод был осуществлен после нужного таймштампа, добавляем его в возвращаемый массив
+                if (thisTransfer.timestamp > fromTimestamp) {
+                    allTransfersOnPeriod[lastIndex++] = thisTransfer;
+                }
+            }
+        }
+    }
+
+    // Получить идентификаторы отправленных переводов
+    function getSentTransfers() public view returns (uint256[] memory) {
+        return users[msg.sender].sentTransfers;
+    }
+
+    // Получить идентификаторы полученных переводов
+    function getRecievedTransfers() public view returns (uint256[] memory) {
+        return users[msg.sender].recievedTransfers;
+    }
+
+    // Получить подробную информацию о переводе по его ID
+    function getTransfer(uint256 transferID)
+        public
+        view
+        returns (Transfer memory)
+    {
+        return transfers[transferID];
+    }
+
+    // Начать голосование за повышение пользователя до уровня админа/проголосовать за повышение
+    function voteForUpgradingUser(address payable user)
+        public
+        onlyAdmin
+        returns (bool success)
+    {
+        uint256 pollIndex = 255555555; // Существует ли такое голосование
+        for (uint128 i = 0; i < userUpgradePollsAddresses.length; i++) {
+            if (userUpgradePollsAddresses[i] == user) {
+                pollIndex = uint128(i);
+                break;
+            }
+        }
+        // Если не существует, создаем новое
+        if (pollIndex == 255555555) userUpgradePollsAddresses.push(user);
+
+        // Голосовал ли админ за повышение этого пользователя или нет
+        bool adminExists;
+        address payable[] memory adminsApproved = userUpgradePolls[user]
+            .adminsApproved;
+        for (uint256 i = 0; i < adminsApproved.length; i++) {
+            if (adminsApproved[i] == msg.sender) {
+                adminExists = true;
+                break;
+            }
+        }
+
+        // Если не голосовал - голосуем
+        if (!adminExists) {
+            userUpgradePolls[user].adminsApproved.push(payable(msg.sender));
+            success = true;
+        }
+
+        // Если нужное количество админов проголосовало - повышаем пользователя
+        if (adminsApproved.length + 1 >= numAdmins) {
+            users[user].admin = true;
+            delete userUpgradePollsAddresses[uint256(pollIndex)];
+        }
+
+        // Если уже голосовал - возвращаем негативный ответ
+        success = false;
+    }
+
+    // Получить список голосований за повышение юзера
+    function getUserUpgradePolls() public view returns (address[] memory) {
+        return userUpgradePollsAddresses;
+    }
+
+    // Получить подробную инфу о голосовании за повышение юзера
+    function getUserUpgradePoll(address user)
+        public
+        view
+        returns (UserUpgradePoll memory)
+    {
+        return userUpgradePolls[user];
+    }
+
+    // Добавить категорию
+    function addCategory(string memory name)
+        public
+        onlyAdmin
+        returns (uint256 categoryID)
+    {
+        categoryID = categoryNames.length - 1;
+        categories[name] = Category(name);
+
+        categoryNames.push(name);
+    }
+
+    // Добавить шаблон
+    function addTemplate(
+        string memory name,
+        uint256 categoryID,
+        uint256[] memory values
+    ) public onlyAdmin returns (uint256 templateID) {
+        templateID = templateNames.length - 1;
+        Template memory newTemplate = Template(name, categoryID, values);
+
+        templateNames.push(name);
+        templates[name] = newTemplate;
+    }
+
+    // Получить названия шаблонов
+    function getTemplateNames() public view returns (string[] memory) {
+        return templateNames;
+    }
+
+    // Получить подробную информацию о шаблоне по его имени
+    function getTemplate(string memory name)
+        public
+        view
+        returns (Template memory)
+    {
+        return templates[name];
+    }
+
+    // Получить имена категорий
+    function getCategoryNames() public view returns (string[] memory) {
+        return categoryNames;
+    }
+
+    // Получить подробную информацию о категории по её имени
+    function getCategory(string memory name)
+        public
+        view
+        returns (Category memory)
+    {
+        return categories[name];
+    }
+
+    // Получить массив шаблонов в категории
+    function getTemplatesOfCategory(uint256 categoryID)
+        public
+        view
+        returns (string[] memory templatesOfCategory)
+    {
+        uint256 lastIndex = 0;
+        for (uint256 i = 0; i < templateNames.length; i++) {
+            Template memory thisTemplate = templates[templateNames[i]];
+
+            if (thisTemplate.categoryID == categoryID) {
+                templatesOfCategory[lastIndex++] = categories[
+                    categoryNames[categoryID]
+                ].name;
+            }
+        }
+    }
+}

Перевод между адресами.txt

@@ -0,0 +1,271 @@
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity >=0.7.0 <0.9.0;
+
+contract Transact
+{
+    // Пользователи
+    struct User
+    {
+        string Name;
+        bytes32 Password;
+        uint Role; // 0 - Админ, 1 - Пользователь
+        uint Balance;
+        bool isExist;
+    }
+    struct Address
+    {
+        uint IDAddress;
+        address addrSender;
+        address addrRecipient;
+        address addrComission;
+    }
+
+    struct CodeWord
+    {
+        uint IDCodeWord;
+        bytes32 codewordHash;
+    }
+
+    struct TransactMoney
+    {
+        uint IDTransfer;
+        uint IDAddress_struct;
+        uint IDCodeWord;
+        string category;
+        string description;
+        uint sum;
+    }
+
+    struct Pattern
+    {
+        uint IDPattern;
+        string Name;
+        string category;
+        string description;
+        uint money;
+    }
+
+    struct UserUp 
+    {                   // структура кандидат
+        string info;    // информация о кандидате
+        address sender; // адрес кандидата в сети
+    }
+
+    // struct Voting
+    // {
+    //     uint IDVoting;
+    //     address UserUp;
+    //     address addrAdminVoting;
+    //     bool ForOrAgainst;
+    // }
+
+    address creator;
+
+    mapping(address => User) public users;
+    
+    User[] users_s;
+
+    Address[] address_struct;
+
+    CodeWord[] codeword_struct;
+
+    TransactMoney[] transactMoney_s;
+
+    Pattern[] pattern_s;
+
+    UserUp[] userup_s;             // массив кандидатов
+    mapping(uint => uint) idVote;       // (id   =>    )  мапа кандидата число голосов
+    mapping(address => bool) userVote;  // (    =>      ) мапа адрес юзера голосовал или нет
+
+    //Voting[] voting_s;
+
+    constructor() 
+    {
+        users[0x5B38Da6a701c568545dCfcB03FcB875f56beddC4] = User("Admin", keccak256(abi.encodePacked("Admin1")), 0, 1000, true);
+        users[0xAb8483F64d9C6d1EcF9b849Ae677dD3315835cb2] = User("Admin", keccak256(abi.encodePacked("Admin2")), 0, 1000, true);
+        users[0x4B20993Bc481177ec7E8f571ceCaE8A9e22C02db] = User("User1", keccak256(abi.encodePacked("User1")), 1, 1000, true);
+        users[0x78731D3Ca6b7E34aC0F824c42a7cC18A495cabaB] = User("User2", keccak256(abi.encodePacked("User2")), 1, 1000, true);
+        users[0x617F2E2fD72FD9D5503197092aC168c91465E7f2] = User("User3", keccak256(abi.encodePacked("User3")), 1, 1000, true);
+        users[0x17F6AD8Ef982297579C203069C1DbfFE4348c372] = User("User4", keccak256(abi.encodePacked("User4")), 1, 1000, true);
+
+        pattern_s.push(Pattern(0, "Gift", "Personal transfer", "Personal transfer", 10));
+        pattern_s.push(Pattern(1, "Gift", "Personal transfer", "Personal transfer", 30));
+        pattern_s.push(Pattern(2, "Gift", "Personal transfer", "Personal transfer", 50));
+        pattern_s.push(Pattern(3, "Rent", "Payment of rental housing", "Personal transfer", 70));
+        pattern_s.push(Pattern(4, "Rent", "Payment of rental housing", "Personal transfer", 90));
+
+        //creator = msg.sender;
+    }
+
+    //Регистрация
+    function RegUser(string memory name_input, string memory password_input, uint role_input) public
+    {
+        require(users[msg.sender].isExist == false, "Users already exist");
+        users[msg.sender] = User(
+            name_input,
+            keccak256(abi.encodePacked(password_input)), 
+            role_input,
+            1000,
+            true
+        );
+    }
+
+    function AuthUser(string memory password_input) public view returns(bool)
+    {
+        require(users[msg.sender].isExist == true, "User not found");
+        if(users[msg.sender].Password == keccak256(abi.encodePacked(password_input)))
+            return true;
+        else
+            return false;
+    }
+
+    function NewAdmin(address addr) public
+    {
+        require(users[msg.sender].Role == 0, "You are not a admin");
+        users[addr].Role = 0;
+    }
+
+    function TransactMoneyFunc(uint IDTransfer_input, address addrRecipient_input, uint sum_input, string memory CodeWord_input, address addrComission_input, string memory category_input, string memory description_input) public
+    {
+        require(users[msg.sender].isExist == true, "User not found");
+        require(users[msg.sender].Balance > sum_input, "Your balance is less than the transfer amount");
+        transactMoney_s.push(TransactMoney(IDTransfer_input, IDTransfer_input, IDTransfer_input, category_input, description_input, sum_input));
+        codeword_struct.push(CodeWord(IDTransfer_input, keccak256(abi.encodePacked(CodeWord_input))));
+        address_struct.push(Address(IDTransfer_input, msg.sender, addrRecipient_input, addrComission_input));
+    }
+    
+    function TransferConfirmation(address addrSender_input, string memory CodeWord_input1, uint IDTransfer_input1) public
+    {
+        require(address_struct[IDTransfer_input1].addrSender != msg.sender, "You are the sender");
+        require(codeword_struct[IDTransfer_input1].codewordHash == keccak256(abi.encodePacked(CodeWord_input1)), "Incorrect code word");
+        users[addrSender_input].Balance -= transactMoney_s[IDTransfer_input1].sum;
+        users[msg.sender].Balance += transactMoney_s[IDTransfer_input1].sum;
+    }
+
+    function Commision(uint IDTransfer_input2) public
+    {
+        require(address_struct[IDTransfer_input2].addrComission == msg.sender, "You are not a sender not a recipient");
+        users[msg.sender].Balance -= transactMoney_s[IDTransfer_input2].sum * 1 / 100;
+    }
+
+    function PatternFunc(uint IDPattern_input, uint IDTransfer_input, address addrRecipient_input, address addrComission_input, string memory CodeWord_input, string memory category_input, string memory description_input) public
+    {
+        address_struct.push(Address(IDTransfer_input, msg.sender, addrRecipient_input, addrComission_input));
+        codeword_struct.push(CodeWord(IDTransfer_input, keccak256(abi.encodePacked(CodeWord_input))));
+        transactMoney_s.push(TransactMoney(IDTransfer_input, IDTransfer_input, IDTransfer_input, category_input, description_input, pattern_s[IDPattern_input].money));
+    }
+
+    // function VotingFunc(uint IDVoting_input, address UserUp_input, address addrAdminVoting_input, bool ForOrAgainst_input) public
+    // {
+    //     // uint IDVoting;
+    //     // address UserUp;
+    //     // address addrAdminVoting;
+    //     // bool[] ForOrAgainst;
+
+    //     voting_s.push(Voting(IDVoting_input, UserUp_input, addrAdminVoting_input, ForOrAgainst_input));
+    // }
+
+    modifier ifOwner(address _sender) 
+    {
+        require(_sender == creator);
+        _;
+    }
+
+    // Функция регистрация нового кандидата
+    function createCan(string memory _info) public 
+    {
+        require(users[msg.sender].Role == 0, "You are not a admin");
+        for (uint i=0; i < userup_s.length; i++) 
+        {                  // [1]
+            require(userup_s[i].sender != msg.sender, "You are already registered as a candidate!");
+        }
+        userup_s.push(UserUp(_info, msg.sender));
+    }
+    
+    // Функция голосование за кандидата
+    function vote(uint _id) external 
+    {
+        require(users[msg.sender].Role == 0, "You are not a admin");
+        require(userVote[msg.sender] != true, "Have you already voted!"); 
+        userVote[msg.sender] = true;
+        idVote[_id]++;
+    }
+    
+    // Функция определение победителя
+    function getWinner() ifOwner(msg.sender) external view returns (uint, uint, uint[] memory) 
+    {
+        require(users[msg.sender].Role == 0, "You are not a admin");
+        uint winner;                                                // [1]
+        uint max;                                                   // [2]
+        uint[] memory tour2;                                        // [3]
+        (winner, max) = getMax();                                   // [4]
+        //tour2 = newTour(max);                                       // [5]
+        return (winner, max, tour2);                                // [6]
+    }
+
+    function UpUser() public 
+    {
+        uint countAdmin;
+        for (uint i = 0; i < userup_s.length; i++)
+        {
+            if (1 > 0)
+            {
+                countAdmin++;
+            }
+        }
+
+        if (users_s.length + 1 >= countAdmin) 
+        {
+            users[msg.sender].Role = 0;
+            //delete userUpgradePollsAddresses[uint256(pollIndex)];
+        }
+    }
+    
+    // Функция определить победителя
+    function getMax() internal view returns (uint, uint)
+    {
+        require(users[msg.sender].Role == 0, "You are not a admin");
+        uint max = 0;                                               // [1]
+        uint winner;                                                // [2]
+        for (uint i=0; i < userup_s.length; i++) 
+        {                  // [3]
+            if (idVote[i] > max) 
+            {                                  // [4]
+                winner = i;                                         // [5]
+                max = idVote[i];                                    // [6]
+            }
+        }
+        return (winner, max);                                       // [7]
+    }
+    
+    // Функция получить описание кандидата
+    function getCan(uint _id) public view returns (string memory) 
+    {
+        require(users[msg.sender].Role == 0, "You are not a admin");
+        return userup_s[_id].info;
+    }
+    
+    // Функция получить статистику кандидата
+    function getCanStat(uint _id) ifOwner(msg.sender) public view returns (uint) 
+    {
+        require(users[msg.sender].Role == 0, "You are not a admin");
+        return idVote[_id];
+    }
+
+    function LookTransact(uint256 transferID_input) public view returns(TransactMoney memory) 
+    {
+        return transactMoney_s[transferID_input];
+    }
+
+    // function LookVoting() public view returns(Voting[] memory) 
+    // {
+    //     return voting_s;
+    // }
+
+    function LookBalance() public view returns(uint) 
+    {
+        require(users[msg.sender].isExist == true, "User not exist");
+        return users[msg.sender].Balance;
+    }
+}

Срез 2 Бори с заполнением комментарий.txt

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.7.0 <0.9.0;
+pragma experimental ABIEncoderV2;
+
+contract Shop
+{
+    struct User
+    {
+    string Name;
+    bytes32 Password;
+    uint Role; //0 - магазин, 1 - администратор, 2 - продавец, 3 - покупатель
+    uint Balance;
+    bool isExist;
+    }
+
+    mapping(address => User) private users;
+    address[] reg;
+    string[] BookOfComplaints;
+
+    function Autorization(string memory _Password) public view returns (bool)
+    {
+        require(users[msg.sender].isExist == true, "User not exits");
+        if(users[msg.sender].Password == keccak256(abi.encodePacked(_Password)))
+            return true;
+        return false;
+    }
+
+    function Registration(string memory _Name, string memory _Password, uint _Role) public
+    {
+        require(users[msg.sender].isExist == false, "Users already exist");
+        users[msg.sender] = User
+        (
+            _Name,
+            keccak256(abi.encodePacked(_Password)),
+            _Role,
+            1000,
+            true 
+        );
+        reg.push(msg.sender);
+    }
+
+    //Администратор
+    //Повышает обычного покупателя до роли продавец
+    function UpdateRoleClientToSeller(address _idUser, uint _idRole) public
+    {
+        require(users[_idUser].Role != 1, "You are not admin");
+        users[_idUser].Role = _idRole;
+    }
+
+    //Понижает продавца до роли покупатель
+    function UpdateRoleSellerToClient(address _idUser, uint _idRole) public
+    {
+        require(users[_idUser].Role != 1, "You are not admin");
+        users[_idUser].Role = _idRole;
+    }
+
+    //Может переключиться к роли покупатель;
+    function UpdateRoleAdminToSeller(address _idUser, uint _idRole) public
+    {
+        require(users[_idUser].Role != 1, "You are not admin");
+        users[_idUser].Role = _idRole;
+    }
+
+    //Может ввести в систему новых администраторов
+    function AddNewAdmin(address _idUser, string memory _Name, string memory _Password) public
+    {
+        require(users[_idUser].Role != 1, "You are not admin");
+        users[msg.sender] = User
+        (
+            _Name,
+            keccak256(abi.encodePacked(_Password)),
+            1,
+            1000,
+            true 
+        );
+        reg.push(msg.sender);
+    }
+
+    //Прдавец
+    //Может оставить комментарий к записи в книге отзывов и предложений
+    function CommentOfBook(address _idUser, string memory _Text) public
+    {
+        require(users[_idUser].Role != 2, "You are not Seller");
+        BookOfComplaints.push(_Text);
+    }
+    
+    //Просмотр книги
+    function ViewBook() public view returns(string[] memory)
+    {
+    return BookOfComplaints;
+    }
+
+    //Может переключиться к роли покупатель
+    function RoleSellerToClient(address _idUser, uint _idRole) public
+    {
+        require(users[_idUser].Role != 2, "You are not Seller");
+        users[_idUser].Role = _idRole;
+    }
+
+    //Может отправить запрос на понижение до роли покупатель;
+    function RequestRoleSellerToClient(address _idUser, uint _idRole) public
+    {
+        require(users[_idUser].Role != 2, "You are not Seller");
+    }
+
+    //Покупатель
+    
+
+}

Срез 2 Бори.txt

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity >=0.7.0 <0.9.0;
+pragma experimental ABIEncoderV2;
+
+contract Shop 
+{
+
+    struct User
+    {
+        bytes32 Password;
+        bool isExist;
+        uint Role; //0 - admin, 1 - seller, 2 - client
+    }
+
+    mapping(address => User) private users;
+    mapping(address => uint) SellersAndClient;
+    address[] reg;
+    address[] adrs;
+    uint[] rols;
+
+    //struct Request
+    //{    
+    //}
+
+    //Пользователь Администратор
+    constructor()  
+    {
+        users[0x5B38Da6a701c568545dCfcB03FcB875f56beddC4] = User
+        (
+                keccak256(abi.encodePacked("6785")),
+                true,
+                0
+        );
+    } 
+
+    //Регистрация (покупатель)
+    function Registration(string memory _Password) public 
+    {
+        require(users[msg.sender].isExist == false, "User already exist");
+        users[msg.sender] = User
+        (
+            keccak256(abi.encodePacked(_Password)),
+            true,
+            2
+        );
+        reg.push(msg.sender);
+    }
+
+    //Авторизация (все)
+    function Autorization(string memory _Password) public view returns(bool)
+    {
+        require(users[msg.sender].isExist == true, "User not exist");
+        if(users[msg.sender].Password == keccak256(abi.encodePacked(_Password)))
+            return true;
+        return false;
+    }
+
+    //Может отправить запрос на понижение до роли покупатель (продавец) 
+    function DowngradeRequestToClient(uint _role) public
+    {
+        require(users[msg.sender].isExist == true, "User not exist");
+        require(users[msg.sender].Role != 1, "You are not saller");
+        
+        SellersAndClient[msg.sender] = _role;
+        adrs.push(msg.sender);
+        rols.push(_role);
+    }
+
+    //Может отправить запрос на повышение до роли продавец(покупатель) 
+    function RequestForPromotionToASeller(uint _role) public
+    {
+        require(users[msg.sender].isExist == true, "User not exist");
+        require(users[msg.sender].Role != 2, "You are not client");
+        
+        SellersAndClient[msg.sender] = _role;
+        adrs.push(msg.sender);
+        rols.push(_role);
+    }
+
+    //Повышает обычного покупателя до роли продавец
+    function clientToSeller(address _adr, uint _role) public
+    {
+       require(users[msg.sender].isExist == true, "User not exist");
+       require(users[msg.sender].Role != 0, "You are not admin"); 
+
+       users[_adr].Role = _role;
+    }
+    
+    //Просмотр заявок 
+    function Viewarray() public view returns(address[] memory, uint[] memory)
+    {
+        return(adrs, rols);
+    }
+}

Ссылки.txt

@@ -0,0 +1 @@
+http://gogs.tomtit.tomsk.ru:3000/ теховский гогс