enum and change of state : state of contract in constructor - if-statement

I am writing a smartcontract which allows to buy an object and to visualize the purchase price with GetTransactionInformation and to visualize the number of purchases made with GetObjectShipped, I am trying to change the state of my smartcontract according to these parameters with my manufacturer so that if I don't buy anything, then my contract is pending, and if I bought my contract then goes shipped, do you have a solution to change these states depending on the items purchased
here my contract
pragma solidity 0.8.7;
contract contracts {
enum shippingStatus1{ shipped, delivered, pending }
constructor (uint shippingStatus1) public {
if (numberShipped == 0)
{state == pending}
else
{state == shipped}
}
struct shippingStatus {
uint buy;
uint numberShipped;
string state;
}
mapping(address => shippingStatus) Sellstatus;
function GetTransactionInformation() public view returns(uint) {
return Sellstatus[msg.sender].buy;
}
function GetOjectshipped() public view returns(uint){
return Sellstatus[msg.sender].numberShipped;
}
receive() external payable{
Sellstatus[msg.sender].buy += msg.value;
// enregistrement du status dans la variable numberShipped
Sellstatus[msg.sender].numberShipped += 1;
}
}

Related

I want to make a time based transaction in smart contract

I am creating smart contract for lottery system and I want to make a time based transaction like a certain amount of players are added into the array then a time stamp should run and on specific time which I will declare should send the amount to the winner,
This is the part where I am stuck, I am trying to enter into the lottery from this this function and when conditions met I want to transfer the amount through the same function cause I want to automate the winner function:
function enter() public payable{
require(msg.value > 1 wei);
players.push(msg.sender);
if(players.length==10){
start = block.timestamp;
}
if(block.timestamp>= start+totalTime){
uint index = random()% players.length;
players[index].transfer(this.balance);
dead[index].transfer((this.balance*2)/100);
winner = players[index];
players = new address[](0);
}
This is my complete code:
pragma solidity ^0.4.26;
contract Lottery{
address public manager;
address[] public players;
address [0x000000000000000000000000000000000000dead] private dead;
address public winner;
uint start;
uint end;
uint totalTime=50;
constructor()public {
manager = msg.sender;
}
function enter() public payable{
require(msg.value > 1 wei);
players.push(msg.sender);
if(players.length==10){
start = block.timestamp;
}
if(block.timestamp>= start+totalTime){
uint index = random()% players.length;
players[index].transfer(this.balance);
dead[index].transfer((this.balance*2)/100);
winner = players[index];
players = new address[](0);
}
}
function random() private view returns (uint){
return uint(keccak256(block.difficulty,now,players));
}
function getBalance() public view returns(uint){
return address(this).balance;
}
function getPlayers() public view returns (address[]){
return players;
}
function getWinner() public view returns (address){
return winner;
}
function getTime() public view returns (uint){
return end-block.timestamp;
}
}
You can't, someone has to call the function and pay the gas fees, what you can do is having an script that listen for events and every time someone "enters" in the lottery and check if already reached the desired amount and then calls the function to get the winner, also you can't have any logic outside a function in solidity, using block difficulty and timestamp as a source of randomness if you are planing to deploy to production is better to use chainlink

Function declared as view error in solidity

pragma solidity >=0.4.16 <0.9.0;
contract Wallet {
uint balance = 0;
bool a = true;
function deposit(uint dep_amt) public {
balance += dep_amt;
}
function withdraw (uint wdraw_amt) public view returns(string memory error){
if(wdraw_amt<=balance){
balance -= wdraw_amt;
}
else{
error = "Insufficient Balance";
return error;
}
}
function getBalnce() public view returns (uint) {
return balance;
}
}
I'm very new to solidity and I'm trying to code a simple bank system which shows the balance and updates the balance according to the deposits and withdraws. I want to display an error in withdraw function when the amount to be withdrawn is greater than the balance but it shows an error saying:
TypeError: Function declared as view, but this expression (potentially) modifies the state and thus requires non-payable (the default) or payable.
Is there a way to possibly show the error from the same function?
If not, Please let me know an alternative.
Thanks in advance!!.
A view function promises not to modify the contract state - such as not to modify storage variables. See the docs for more info.
But your code modifies the balance variable, which is a storage variable.
function withdraw (uint wdraw_amt) public view returns(string memory error){
if(wdraw_amt<=balance){
balance -= wdraw_amt; // <-- here
}
and updates the balance according to the deposits and withdraws
Since one of your requirements is to actually update the storage variable, you need to remove the view modifier in order to be able to do that.
function withdraw (uint wdraw_amt) public returns(string memory error){
Users will then need to send a transaction (not a call) to execute the withdraw() function.
When you have a function executed by a transaction (and not by a call), you can get the string output in two ways.
Revert reason message
function withdraw(uint wdraw_amt) public {
if (wdraw_amt <= balance) {
balance -= wdraw_amt;
} else {
revert("Insufficient Balance");
}
}
Event log
event Error(string _message);
function withdraw(uint wdraw_amt) public {
if (wdraw_amt <= balance) {
balance -= wdraw_amt;
} else {
emit Error("Insufficient Balance");
}
}

Staking contract based on time: need to avoid loop

we are building a staking smart contract on the ethereum mainnet. All the stakes will need to have a timestamp attached to it, so our logic relies on time.
The logic is at the end of the month each stakeholders will have credits, and based on that the contract owner will attribute rewards to each stakeholders based on their creditsAmount. But in order to get the total creditsAmount we need to iterate through the list of stakeHolders, which is super expensive.
Here is a very short example of our staking contract:
pragma solidity 0.8.6;
import “#openzeppelin/contracts/utils/structs/EnumerableSet.sol”;
contract Test {
using EnumerableSet for EnumerableSet.AddressSet;
struct Stake {
uint256 lockedToken;
uint256 creditsEarned; // numberOfDays * lockedToken = 15days * 1000 = 15000
}
// Rewards = RatioOfCreditsEarnedByStakeholder * MonthlyRewards
EnumerableSet.AddressSet private stakeholders;
mapping(address => Stake) private stakeholderToStake;
function createStake(
address stakeholder,
uint256 lockedToken,
uint256 creditsEarned
) public {
stakeholders.add(stakeholder);
stakeholderToStake[stakeholder] = Stake({
lockedToken: lockedToken,
creditsEarned: creditsEarned
});
}
function distributeRewards() public {
uint256 totalCredits = 0;
for (uint256 i = 0; i < stakeholders.length(); i++) {
totalCredits += stakeholderToStake[stakeholders.at(i)].creditsEarned;
}
}
}
So as you can imagine the very last loop is extremely costly but we did not find another way to do so for now. Do you have any idea proposition on how to avoid such loop? or other staking contract which relies on time like us?
Thanks
To expand on my comments, this is how I will do it.
pragma solidity 0.8.6;
import “#openzeppelin/contracts/utils/structs/EnumerableSet.sol”;
contract Test {
using EnumerableSet for EnumerableSet.AddressSet;
struct Stake {
uint256 lockedToken;
uint256 creditsEarned;
}
// Rewards = RatioOfCreditsEarnedByStakeholder * MonthlyRewards
EnumerableSet.AddressSet private stakeholders;
mapping(address => Stake) private stakeholderToStake;
uint256 private totalCredits;
function createStake(
address stakeholder,
uint256 lockedToken,
uint256 creditsEarned
) public {
stakeholders.add(stakeholder);
stakeholderToStake[stakeholder] = Stake({
lockedToken: lockedToken,
creditsEarned: creditsEarned
});
totalCredits += creditsEarned;
}
function distributeRewards() public {
//do whatever you want with totalCredits here
}

Implementing buying and selling in Solidity

So i want to be able to buy/sell the token, but also have the ability for users to send eth to my contract wallet and receive my tokens in exchange. I believe i have the code ready for buyers and sellers to make a transaction together, dont think i have the pieces for someone to recieve tokens for sending me ethereum. I would like to make it so at the start people send me eth for a number of coins set at a base value
pragma solidity 0.4.22;
contract ERC20Basic {
string public constant name = "Community Token";
string public constant symbol = "COMM";
uint8 public constant decimals = 1;
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Transfer(address indexed from, address indexed to, uint tokens);
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
uint256 totalSupply_;
using SafeMath for uint256;
constructor(uint256 total) public {
totalSupply_ = total;
balances[msg.sender] = totalSupply_;
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function balanceOf(address tokenOwner) public view returns (uint) {
return balances[tokenOwner];
}
function transfer(address receiver, uint numTokens) public returns (bool) {
require(numTokens <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(numTokens);
balances[receiver] = balances[receiver].add(numTokens);
emit Transfer(msg.sender, receiver, numTokens);
return true;
}
function approve(address delegate, uint numTokens) public returns (bool) {
allowed[msg.sender][delegate] = numTokens;
emit Approval(msg.sender, delegate, numTokens);
return true;
}
function allowance(address owner, address delegate) public view returns (uint) {
return allowed[owner][delegate];
}
function transferFrom(address owner, address buyer, uint numTokens) public returns (bool) {
require(numTokens <= balances[owner]);
require(numTokens <= allowed[owner][msg.sender]);
balances[owner] = balances[owner].sub(numTokens);
allowed[owner][msg.sender] = allowed[owner][msg.sender].sub(numTokens);
balances[buyer] = balances[buyer].add(numTokens);
emit Transfer(owner, buyer, numTokens);
return true;
}
}
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
A very basic example of buy and sell:
pragma solidity ^0.8;
contract ERC20Basic{
uint256 public constant tokenPrice = 5; // 1 token for 5 wei
function buy(uint256 _amount) external payable {
// e.g. the buyer wants 100 tokens, needs to send 500 wei
require(msg.value == _amount * tokenPrice, 'Need to send exact amount of wei');
/*
* sends the requested amount of tokens
* from this contract address
* to the buyer
*/
transfer(msg.sender, _amount);
}
function sell(uint256 _amount) external {
// decrement the token balance of the seller
balances[msg.sender] -= _amount;
increment the token balance of this contract
balances[address(this)] += _amount;
/*
* don't forget to emit the transfer event
* so that external apps can reflect the transfer
*/
emit Transfer(msg.sender, address(this), _amount);
// e.g. the user is selling 100 tokens, send them 500 wei
payable(msg.sender).transfer(amount * tokenPrice);
}
}
This will allow any user to buy or sell tokens from/to your contract. Your contract will need to own these tokens in order to sell them to the users. Also your contract will need to have enough ETH in order to buy back tokens from the users.
You can expand on this code to implement
a contract owner that is authorized to change the price
different prices for buy and sell
fees
min/max amounts (per one transaction, per user, per day, ...)
calculating the amount of tokens based on the msg.value (the user won't have to have the exact amount)
etc...
Note that my snippet is using Solidity 0.8 where integer overflow is prevented automatically. The question is using deprecated Solidity 0.4, so that you'd need to use SafeMath, check the value with require/assert or upgrade to Solidity 0.8 to reach the same result.

Why am I getting this error ? "Gas estimation errored with the following message (see below). The transaction > execution will likely fail"

Trying to test solidity using Remix IDE. I keep getting the error:
Gas estimation errored with the following message (see below). The transaction > execution will likely fail. Do you want to force sending?
Does anybody have an idea about what might be giving me this error. It I am trying to sell products using the ethereum smart contracts. I have used the Remix IDE to create this contract with value = 0.
I am successfully able to create the contract and add_product but I am unable to Buy. The last line give me the error mentionned above.
The solidity file I am testing againt is the following: As you can see I create a Sell contract which would allow a user to sell products using the blockchain and a buyer to retrieve the product paying the price in ethereum. If anyone has a better solution for me to use for this exact use-case I am opened to suggestions.
pragma solidity ^0.4.0;
contract Sell {
struct Product_Quantity{
string _product_name;
uint256 _product_quantity;
uint256 _price_unity;
bool isValue;
}
struct Seller{
address _id;
mapping(string => Product_Quantity) products;
}
Seller public seller;
mapping (address => Product_Quantity) product_owners;
function Sell(){
seller._id = msg.sender;
}
function add_product(string product_name, uint256 product_quantity, uint256 price_unity) {
if(msg.sender != seller._id) throw;
if(seller.products[product_name].isValue){
seller.products[product_name]._product_quantity += product_quantity;
}
else{
seller.products[product_name] = Product_Quantity(product_name, product_quantity, price_unity, true);
}
}
function Buy( string product_name, uint256 quantity) payable {
if(product_owners[msg.sender].isValue){
product_owners[msg.sender]._product_quantity += quantity;
}
else{
product_owners[msg.sender] = Product_Quantity(product_name, quantity, seller.products[product_name]._price_unity, true);
}
seller.products[product_name]._product_quantity -= quantity;
seller._id.transfer(seller.products[product_name]._price_unity * quantity);
}
}
That's a very generic Remix error message. Fortunately, today I'm seeing new error messages on Remix (nice update guys!), which makes it easier to debug the problem.
When someone tries to buy a product, you should check if the value passed (in wei) is the right amount to buy that product and quantity.
Since you're not checking that, a buyer can buy a product with an amout equals to 0, which means the contract will have no wei to send to the seller at the end of the buy() function. That will throw an exception and the transaction will be reverted.
I updated your code to run on solidity 0.4.23 (latest version), made some code refactoring and add a modifier to the buy() function to check if the amount passed is correct.
pragma solidity ^0.4.23;
contract Sell {
struct Product_Quantity{
string _product_name;
uint256 _product_quantity;
uint256 _price_unity;
bool isValue;
}
mapping (address => Product_Quantity) product_owners;
struct Seller{
address _id;
mapping(string => Product_Quantity) products;
}
Seller public seller;
constructor() public {
seller._id = msg.sender;
}
function add_product (string product_name, uint256 product_quantity, uint256 price_unity) public {
require(msg.sender == seller._id);
if (seller.products[product_name].isValue) {
seller.products[product_name]._product_quantity += product_quantity;
}
else{
seller.products[product_name] = Product_Quantity(product_name, product_quantity, price_unity, true);
}
}
modifier hasEnoughEther (string product_name, uint256 quantity) {
require (seller.products[product_name].isValue); // does the product exists?
uint256 neededEther = seller.products[product_name]._price_unity * quantity;
require (msg.value == neededEther); // did the buyer sent the correct value?
_;
}
function buy (string product_name, uint256 quantity) payable public hasEnoughEther (product_name, quantity) {
if (product_owners[msg.sender].isValue) {
product_owners[msg.sender]._product_quantity += quantity;
} else {
product_owners[msg.sender] = Product_Quantity(product_name, quantity, seller.products[product_name]._price_unity, true);
}
seller.products[product_name]._product_quantity -= quantity;
seller._id.transfer(seller.products[product_name]._price_unity * quantity);
}
}
In my case, I needed to fund my contract so it can perform operations.
In your case you are trying to use a MODIFIER function with arguments but have not passed any parameters to it in the Buy function.
And in my case I was trying to trigger a non-payable function with some ether in the VALUE field of the Deploy and Run Transactions tab.