Sure! Here's an example of a basic smart contract written in Solidity that allows for the sale of an electric razor scooter:

```
pragma solidity ^0.8.0;

contract RazorScooterSale {
    address payable public seller;
    address payable public buyer;
    uint public price;
    bool public sold;

    constructor() {
        seller = payable(msg.sender);
        price = 1 ether; // Set the price to 1 ether
        sold = false;
    }

    function buy() public payable {
        require(msg.value == price, "Price must be exactly 1 ether"); // Check that the buyer has sent the correct amount of ether
        require(!sold, "The scooter has already been sold"); // Check that the scooter has not already been sold
        buyer = payable(msg.sender);
        seller.transfer(msg.value);
        sold = true;
    }
}
```

In this contract, we have a `seller` address that represents the person selling the scooter, a `buyer` address that represents the person buying the scooter, a `price` variable that represents the price of the scooter (set to 1 ether in this example), and a `sold` boolean variable that tracks whether the scooter has been sold or not.

The `constructor` function sets the `seller` address to the address of the contract creator and sets the initial price and sold status.

The `buy` function is what allows a buyer to purchase the scooter. It checks that the buyer has sent exactly 1 ether, and that the scooter has not already been sold. If both of these conditions are met, the `buyer` address is set to the address of the person calling the function, the `seller` address receives the 1 ether payment, and the `sold` variable is set to true.

Note that this is a very basic example and does not include any error handling or additional features like shipping or return policies. A real-world smart contract for selling a scooter would likely need to include additional functionality and security measures.
แน่นอน! นี่คือตัวอย่างของสัญญาอัจฉริยะขั้นพื้นฐานที่เขียนด้วย Solidity ที่อนุญาตให้ขายสกู๊ตเตอร์ไฟฟ้าแบบมีดโกนได้: ``` pragma solidity ^0.8.0; สัญญา RazorScooterSale { ที่อยู่ผู้ขายสาธารณะเจ้าหนี้; ที่อยู่ผู้ซื้อสาธารณะเจ้าหนี้; ไม่ใช่ราคาสาธารณะ บูลขายสาธารณะ; ตัวสร้าง () { ผู้ขาย = เจ้าหนี้ (msg.sender); ราคา = 1 อีเธอร์; // ตั้งราคาเป็น 1 อีเทอร์ที่ขาย = false; } ฟังก์ชั่น buy() เจ้าหนี้สาธารณะ { need(msg.value == price, "ราคาต้องเป็น 1 อีเธอร์"); // ตรวจสอบว่าผู้ซื้อได้ส่ง ether ที่ต้องการในปริมาณที่ถูกต้อง(!sold, "Theสกู๊ตเตอร์ได้ถูกขายไปแล้ว"); // ตรวจสอบว่าสกู๊ตเตอร์ยังไม่ได้ถูกขาย ผู้ซื้อ = เจ้าหนี้ (msg.sender); ผู้ขายโอน(msg.value); ขาย = จริง; } } ``` ในสัญญานี้ เรามีที่อยู่ "ผู้ขาย" ที่แสดงถึงบุคคลที่ขายสกู๊ตเตอร์ ที่อยู่ "ผู้ซื้อ" ที่แสดงถึงบุคคลที่ซื้อสกู๊ตเตอร์ ตัวแปร "ราคา" ที่แสดงถึงราคาของสกู๊ตเตอร์ ( ในตัวอย่างนี้ตั้งค่าเป็น 1 อีเทอร์) และตัวแปรบูลีน 'ขายแล้ว' ที่ติดตามว่าสกู๊ตเตอร์ขายไปแล้วหรือไม่ ฟังก์ชัน `constructor` จะตั้งค่าที่อยู่ `ผู้ขาย` ไปยังที่อยู่ของผู้สร้างสัญญา และกำหนดราคาเริ่มต้นและสถานะการขาย ฟังก์ชั่น "ซื้อ" คือสิ่งที่ช่วยให้ผู้ซื้อสามารถซื้อสกู๊ตเตอร์ได้ จะตรวจสอบว่าผู้ซื้อได้ส่งอีเธอร์ 1 รายการอย่างแน่นอน และสกู๊ตเตอร์ยังไม่ได้ถูกขาย หากตรงตามเงื่อนไขทั้งสองข้อนี้ ที่อยู่ "ผู้ซื้อ" จะถูกตั้งค่าเป็นที่อยู่ของบุคคลที่เรียกใช้ฟังก์ชัน ที่อยู่ "ผู้ขาย" จะได้รับการชำระเงิน 1 อีเธอร์ และตัวแปร "ขายแล้ว" จะถูกตั้งค่าเป็นจริง โปรดทราบว่านี่เป็นตัวอย่างพื้นฐานและไม่มีการจัดการข้อผิดพลาดหรือคุณลักษณะเพิ่มเติม เช่น นโยบายการจัดส่งหรือการคืนสินค้า สัญญาอัจฉริยะในโลกแห่งความเป็นจริงสำหรับการขายสกู๊ตเตอร์น่าจะต้องมีฟังก์ชันการทำงานเพิ่มเติมและมาตรการรักษาความปลอดภัย
spam fails_task lang_mismatch pii not_appropriate hate_speech sexual_content quality toxicity humor helpfulness creativity violence