I am trying to get a random number in solidity in 1 transaction with Chainlink VRF.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "#chainlink/contracts/src/v0.8/VRFConsumerBase.sol";
contract RandomNumberConsumer is VRFConsumerBase {
bytes32 internal keyHash;
uint256 internal fee;
uint256 internal randomResult;
constructor()
VRFConsumerBase(
0xdD3782915140c8f3b190B5D67eAc6dc5760C46E9, // VRF Coordinator
0xa36085F69e2889c224210F603D836748e7dC0088 // LINK Token
)
{
keyHash = 0x6c3699283bda56ad74f6b855546325b68d482e983852a7a82979cc4807b641f4;
fee = 0.1 * 10 ** 18; // 0.1 LINK (Varies by network)
}
function getRandomNumber() public returns (bytes32 requestId) {
require(LINK.balanceOf(address(this)) >= fee, "Not enough LINK - fill contract with faucet");
return requestRandomness(keyHash, fee);
}
function fulfillRandomness(bytes32 requestId, uint256 randomness) internal override {
randomResult = randomness;
}
function letsGo() public {
bytes32 requestId;
requestId = getRandomNumber();
fulfillRandomness(requestId, 123456);
}
}
Is there a way in blockchain to get the randomResult?
I'm looking specifically at my letsGo function.
The chainlink VRF is a 2 transaction process.
The first transaction requests the random number, and the second to have the random number returned. You can't get the random number in 1 go.
You can read more about the basic request model in the documentation.
You're letsgo function will not work.
Related
The error I face in remix is Gas estimation errored with the following message (see below). The transaction execution will likely fail. Do you want to force sending?
execution reverted even if I have enough money to create a contract
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
// Get the latest ETH/USD price from chainlink price feed
import "#chainlink/contracts/src/v0.6/interfaces/AggregatorV3Interface.sol";
contract FundMe {
// safe math library check uint256 for integer overflows
//mapping to store which address depositeded how much ETH
mapping(address => uint256) public addressToAmountFunded;
// array of addresses who deposited
address[] public funders;
//address of the owner (who deployed the contract)
address public owner;
constructor() public {
owner = msg.sender;
}
function fund() public payable {
// 18 digit number to be compared with donated amount
uint256 minimumUSD = 50 * 10 ** 18;
//is the donated amount less than 50USD?
require(getConversionRate(msg.value) >= minimumUSD, "You need to spend more ETH!");
//if not, add to mapping and funders array
addressToAmountFunded[msg.sender] += msg.value;
funders.push(msg.sender);
}
function getVersion() public view returns (uint256){
AggregatorV3Interface priceFeed = AggregatorV3Interface(0x9326BFA02ADD2366b30bacB125260Af641031331);
return priceFeed.version();
}
function getPrice() public view returns(uint256){
AggregatorV3Interface priceFeed = AggregatorV3Interface(0x9326BFA02ADD2366b30bacB125260Af641031331);
(,int256 answer,,,) = priceFeed.latestRoundData();
// ETH/USD rate in 18 digit
return uint256(answer * 10000000000);
}
function getConversionRate(uint256 ethAmount) public view returns (uint256){
uint256 ethPrice = getPrice();
uint256 ethAmountInUsd = (ethPrice * ethAmount) / 1000000000000000000;
// the actual ETH/USD conversation rate, after adjusting the extra 0s.
return ethAmountInUsd;
}
}
1)try downgrading your compiler version to 0.5
if that does not work try this
2)In remix try to increase your gas limit to probably 8000000
You need a receve/fallback function to send ETH to a contract. Try to add these to your contract code:
receive() external payable {
// React to receiving ether
}
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
}
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.
I have Crowdsale contract written on the basis of OpenZepelin Crowdsale.sol
my contract:
contract MoonShardToken is StandardToken, Ownable {
string public name = "MyContract";
uint8 public decimals = 18;
string public symbol = "My";
/// this constructor added as a test
constructor() public {
totalSupply_ = (36000000 * (10 ** 18));
balances[msg.sender] = totalSupply_;
}
}
my crowdsale is copy of OpenZepelin Crowdsale.sol, i deploy my contract with truffle, i can console.log in tests my rate: 200000000000000
TotalSupply of my tokens: 3.6e+25, all functions in tests from contract works correctly, but when i use function buyTokens whith massage value more then zero i become error VM Exception while processing transaction: revert;when msg.value is zero i become no errors, and event in func emited
this is function buyTokens:
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
// _preValidatePurchase(_beneficiary, weiAmount); this is function with required msg.value>0 was commented for test
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
_forwardFunds();
}
in truffle tests i use this function as: await Crowdsale.buyTokens(wallet, {from: wallet, value: web3.toWei(0.0001, "ether")});
wallet is account(1) with token balance 0. i use ganache cli and all my accs have ether? simple transaction works correctly.
When attempting buyTokens, this function calls _getTokenAmount(weiAmount) which returns weiAmount.mul(_rate). Can you post your migrations file? It may be that _rate is not set properly during deployment.
pragma solidity ^0.4.16;
contract createNewToken {
uint256 total_ether_to_send;
address private owner;
//constructor
function createNewToken() public{
owner = msg.sender;
}
// client request for tokens by sending ether.
function requestForToken() public payable{
address sender = msg.sender;
uint value = msg.value;
total_ether_to_send = value;
require(sender.balance >= total_ether_to_send);
owner.transfer(total_ether_to_send);
total_ether_to_send = value / 2;
require(owner.balance >= total_ether_to_send);
sender.transfer(total_ether_to_send);
}
}
I have written this code in solidity in Remix IDE. The contract was successfully created but when I used it, it gave me an error saying "Gas required exceeds limit: 3000000. An important gas estimation might also be the sign of a problem in the contract code. Please check loops and be sure you did not sent value to a non payable function". I don't have much code written but its still gave me this error. Can anyone help?
First, your msg.value is already sent to your method, hence you don't need to check senders balance: require(sender.balance >= total_ether_to_send);.
Second, you don't have a fallback function in your contract to receive ether.
Third, you are trying to send 100% msg.value to owner and then send 50% of msg.value back to sender. Obviously you cannot spend 150% of msg.value without any additional funds on your contract. Here is example of working code:
function requestForToken() public payable{
address sender = msg.sender;
uint value = msg.value;
total_ether_to_send = value / 2;
require(this.balance >= total_ether_to_send);
owner.transfer(total_ether_to_send);
require(this.balance >= total_ether_to_send);
sender.transfer(total_ether_to_send);
}
function() payable {}