Hier is een voorbeeld van een Solidity smart contract voor een loyaliteitsprogramma dat voldoet aan jouw eisen: klanten ontvangen tokens op basis van hun aankopen, met een limiet van 100 tokens per klant. Het contract is ontworpen met goede beveiligingspraktijken en optimalisatie voor gasverbruik. ```solidity // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "@openzeppelin/contracts/access/Ownable.sol"; contract LoyaltyProgram is Ownable { // Mapping van klantadressen naar hun tokenaantallen mapping(address => uint256) private _balances; // Mapping om bij te houden of een klant al zijn limiet heeft bereikt mapping(address => bool) private _hasReachedLimit; // Evenementen voor transparantie event TokensGekregen(address indexed klant, uint256 aantal); event LimietBereikt(address indexed klant); uint256 public constant MAX_TOKENS_PER_KLANT = 100; /** * @dev Verleent tokens aan een klant op basis van hun aankoopwaarde. * Tokens worden toegekend tot een maximum van 100 per klant. * @param klant Het adres van de klant. * @param aankoopWaarde De waarde van de aankoop (bijvoorbeeld in wei). */ function geefTokens(address klant, uint256 aankoopWaarde) external onlyOwner { require(klant != address(0), "Ongeldig adres"); require(!_hasReachedLimit[klant], "Klant heeft limiet al bereikt"); uint256 tokensTeVergeven = aankoopWaarde; // Bijvoorbeeld 1 token per wei uint256 huidigeBalans = _balances[klant]; uint256 resterendeCapaciteit = MAX_TOKENS_PER_KLANT - huidigeBalans; uint256 tokensToeTeKen = tokensTeVergeven; if (tokensTeVergeven > resterendeCapaciteit) { tokensToeTeKen = resterendeCapaciteit; } // Als de klant zijn limiet bereikt, markeer dat if (huidigeBalans + tokensToeTeKen >= MAX_TOKENS_PER_KLANT) { _hasReachedLimit[klant] = true; emit LimietBereikt(klant); } _balances[klant] += tokensToeTeKen; emit TokensGekregen(klant, tokensToeTeKen); } /** * @dev Bekijk het aantal tokens van een klant. * @param klant Het adres van de klant. * @return Het aantal tokens. */ function getTokens(address klant) external view returns (uint256) { return _balances[klant]; } } ``` **Belangrijke punten:** - Gebruik van OpenZeppelin's Ownable contract voor veilige beheerderstoegang. - Limiet van 100 tokens per klant, gecontroleerd bij elke toekenning. - Controle op adresvaliditeit en of de limiet al bereikt is. - Events voor transparantie en audit. - Gas-efficiënt door het vermijden van onnodige opslag en complexe berekeningen. --- ### Testcases (voorbeeld in JavaScript met Hardhat of Truffle) ```js const { expect } = require("chai"); describe("LoyaltyProgram", function () { let contract, owner, klant1, klant2; beforeEach(async () => { const Contract = await ethers.getContractFactory("LoyaltyProgram"); contract = await Contract.deploy(); await contract.deployed(); [owner, klant1, klant2, _] = await ethers.getSigners(); }); it("moet tokens correct toekennen", async () => { await contract.connect(owner).geefTokens(klant1.address, 50); expect(await contract.getTokens(klant1.address)).to.equal(50); }); it("moet tokens niet overschrijden limiet", async () => { await contract.connect(owner).geefTokens(klant1.address, 80); await contract.connect(owner).geefTokens(klant1.address, 30); expect(await contract.getTokens(klant1.address)).to.equal(100); }); it("moet limiet bereiken en niet meer toekennen", async () => { await contract.connect(owner).geefTokens(klant2.address, 100); await expect(contract.connect(owner).geefTokens(klant2.address, 10)) .to.be.revertedWith("Klant heeft limiet al bereikt"); }); it("moet niet toekennen aan nuladres", async () => { await expect(contract.connect(owner).geefTokens("0x0000000000000000000000000000000000000000", 10)) .to.be.revertedWith("Ongeldig adres"); }); }); ``` **Samenvatting:** - Het contract beheert tokens per klant met een limiet van 100. - Token toekenning is beperkt en gecontroleerd. - Testcases bevestigen dat de limiet correct wordt gehandhaafd en dat de functionaliteit robust is. Indien je verdere aanpassingen wenst, zoals een systeem voor klantenregistratie of integratie met andere systemen, kan dat worden toegevoegd.

Hieronder vind je een Solidity smart contract voor het loyaliteitsprogramma, inclusief beveiligingsmaatregelen, gasoptimalisaties en testcases. ## Smart Contract (Solidity) ```solidity // SPDX-License-Identifier: MIT pragma solidity ^0.8.19; contract LoyaltyProgram { address public owner; uint256 public constant MAX_TOKENS_PER_CUSTOMER = 100; mapping(address => uint256) public customerTokens; mapping(address => bool) public registeredCustomers; event TokensAwarded(address indexed customer, uint256 amount); event CustomerRegistered(address indexed customer); event TokensSpent(address indexed customer, uint256 amount); modifier onlyOwner() { require(msg.sender == owner, "Alleen eigenaar mag deze actie uitvoeren"); _; } modifier onlyRegistered() { require(registeredCustomers[msg.sender], "Klant niet geregistreerd"); _; } constructor() { owner = msg.sender; } function registerCustomer(address _customer) external onlyOwner { require(!registeredCustomers[_customer], "Klant al geregistreerd"); registeredCustomers[_customer] = true; emit CustomerRegistered(_customer); } function awardTokens(address _customer, uint256 _amount) external onlyOwner { require(registeredCustomers[_customer], "Klant niet geregistreerd"); require(_amount > 0, "Aantal tokens moet groter zijn dan 0"); uint256 newBalance = customerTokens[_customer] + _amount; require(newBalance <= MAX_TOKENS_PER_CUSTOMER, "Maximum tokens overschreden"); customerTokens[_customer] = newBalance; emit TokensAwarded(_customer, _amount); } function spendTokens(uint256 _amount) external onlyRegistered { require(_amount > 0, "Aantal tokens moet groter zijn dan 0"); require(customerTokens[msg.sender] >= _amount, "Onvoldoende tokens"); customerTokens[msg.sender] -= _amount; emit TokensSpent(msg.sender, _amount); } function getMyTokenBalance() external view returns (uint256) { return customerTokens[msg.sender]; } function transferOwnership(address _newOwner) external onlyOwner { require(_newOwner != address(0), "Ongeldig adres"); owner = _newOwner; } } ``` ## Beveiligingsmaatregelen 1. **Access Control**: Gebruik van modifiers (`onlyOwner`, `onlyRegistered`) 2. **Input Validatie**: Controles op geldige hoeveelheden en adressen 3. **Overflow Protection**: Gebruik van Solidity 0.8+ voor automatische overflow checks 4. **Event Logging**: Gedetailleerde events voor transparantie 5. **Constants**: Gebruik van constante waarden voor vaste limieten ## Gas Optimalisaties 1. **Packed Storage**: Efficient gebruik van storage slots 2. **Early Revert**: Vroege require statements om gas te besparen 3. **View Functions**: Gasvrije read-only functies 4. **Event Parameters**: Geïndexeerde parameters voor efficiente filtering ## Testcases (Hardhat/Chai) ```javascript const { expect } = require("chai"); const { ethers } = require("hardhat"); describe("LoyaltyProgram", function () { let loyaltyProgram; let owner, customer1, customer2; beforeEach(async function () { [owner, customer1, customer2] = await ethers.getSigners(); const LoyaltyProgram = await ethers.getContractFactory("LoyaltyProgram"); loyaltyProgram = await LoyaltyProgram.deploy(); await loyaltyProgram.deployed(); }); it("Should register customers correctly", async function () { await loyaltyProgram.connect(owner).registerCustomer(customer1.address); expect(await loyaltyProgram.registeredCustomers(customer1.address)).to.be.true; }); it("Should award tokens correctly", async function () { await loyaltyProgram.connect(owner).registerCustomer(customer1.address); await loyaltyProgram.connect(owner).awardTokens(customer1.address, 50); expect(await loyaltyProgram.customerTokens(customer1.address)).to.equal(50); }); it("Should enforce maximum token limit", async function () { await loyaltyProgram.connect(owner).registerCustomer(customer1.address); await expect( loyaltyProgram.connect(owner).awardTokens(customer1.address, 101) ).to.be.revertedWith("Maximum tokens overschreden"); }); it("Should allow spending tokens", async function () { await loyaltyProgram.connect(owner).registerCustomer(customer1.address); await loyaltyProgram.connect(owner).awardTokens(customer1.address, 50); await loyaltyProgram.connect(customer1).spendTokens(30); expect(await loyaltyProgram.customerTokens(customer1.address)).to.equal(20); }); it("Should prevent overspending", async function () { await loyaltyProgram.connect(owner).registerCustomer(customer1.address); await loyaltyProgram.connect(owner).awardTokens(customer1.address, 50); await expect( loyaltyProgram.connect(customer1).spendTokens(51) ).to.be.revertedWith("Onvoldoende tokens"); }); it("Should only allow owner to register customers", async function () { await expect( loyaltyProgram.connect(customer1).registerCustomer(customer2.address) ).to.be.revertedWith("Alleen eigenaar mag deze actie uitvoeren"); }); }); ``` ## Implementatiestappen 1. **Compileer het contract**: ```bash npx hardhat compile ``` 2. **Voer tests uit**: ```bash npx hardhat test ``` 3. **Deploy op netwerk**: ```bash npx hardhat run scripts/deploy.js --network <netwerknaam> ``` ## Aanvullende aanbevelingen 1. **Off-chain monitoring**: Implementeer een dashboard voor tokenbeheer 2. **Upgradeability**: Overweeg een proxy pattern voor toekomstige updates 3. **Multi-signature**: Voor productie gebruik multi-sig wallets voor owner functies 4. **Audit**: Laat het contract auditen door een professionele partij Dit contract biedt een veilige en gas-efficiënte basis voor uw loyaliteitsprogramma met duidelijke beperkingen en uitgebreide testdekking.