// Obtener Capital Invertido en tokens
function equity_in_soveringcoin[address investor]external view returns (uint) {
return equity_soveringcoin[investor];
}
creation of SuperRareTokenCreatorRegistry errored: Error encoding arguments: Error: types/values length mismatch (count={"types":1,"values":2}, value={"types":["address[]"],"values":["[0x5B38Da6a701c568545dCfcB03FcB875f56beddC4,",",0x4B20993Bc481177ec7E8f571ceCaE8A9e22C02db]"]}, code=INVALID_ARGUMENT, version=abi/5.0.7)
How to pass an array of addresses to function. It is giving me the error.
pragma solidity 0.6.12;
abstract contract Token {
function balanceOf(address who) external view virtual returns (uint256);
function allowance(address owner, address spender) external view virtual returns (uint256);
function transfer(address to, uint256 value) external virtual returns (bool);
function approve(address spender, uint256 value) external virtual returns (bool);
function approveAndCall(address spender, uint tokens, bytes memory data) external virtual returns (bool success);
function transferFrom(address from, address to, uint256 value) external virtual returns (bool);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function ceil(uint256 a, uint256 m) internal pure returns (uint256) {
uint256 c = add(a,m);
uint256 d = sub(c,1);
return mul(div(d,m),m);
}
}
contract owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}}
contract bscLockToken is owned{
using SafeMath for uint256;
/*
* deposit vars
*/
struct Items {
address tokenAddress;
address withdrawalAddress;
uint256 tokenAmount;
uint256 unlockTime;
bool withdrawn;
}
uint256 public depositId;
uint256[] public allDepositIds;
mapping (address => uint256[]) public depositsByWithdrawalAddress;
mapping (uint256 => Items) public lockedToken;
mapping (address => mapping(address => uint256)) public walletTokenBalance;
event LogWithdrawal(address SentToAddress, uint256 AmountTransferred);
/**
* Constrctor function
*/
constructor() public {
}
/**
*lock tokens
*/
function lockTokens(address _tokenAddress, uint256 _amount, uint256 _unlockTime) public returns (uint256 _id) {
require(_amount > 0, 'token amount is Zero');
require(_unlockTime < 10000000000, 'Enter an unix timestamp in seconds, not miliseconds');
require(Token(_tokenAddress).approve(address(this), _amount), 'Approve tokens failed');
require(Token(_tokenAddress).transferFrom(msg.sender, address(this), _amount), 'Transfer of tokens failed');
//update balance in address
walletTokenBalance[_tokenAddress][msg.sender] = walletTokenBalance[_tokenAddress][msg.sender].add(_amount);
address _withdrawalAddress = msg.sender;
_id = ++depositId;
lockedToken[_id].tokenAddress = _tokenAddress;
lockedToken[_id].withdrawalAddress = _withdrawalAddress;
lockedToken[_id].tokenAmount = _amount;
lockedToken[_id].unlockTime = _unlockTime;
lockedToken[_id].withdrawn = false;
allDepositIds.push(_id);
depositsByWithdrawalAddress[_withdrawalAddress].push(_id);
}
/**
*withdraw tokens
*/
function withdrawTokens(uint256 _id) public {
require(block.timestamp >= lockedToken[_id].unlockTime, 'Tokens are locked');
require(msg.sender == lockedToken[_id].withdrawalAddress, 'Can withdraw by withdrawal Address only');
require(!lockedToken[_id].withdrawn, 'Tokens already withdrawn');
require(Token(lockedToken[_id].tokenAddress).transfer(msg.sender, lockedToken[_id].tokenAmount), 'Transfer of tokens failed');
lockedToken[_id].withdrawn = true;
//up
I'm a complete noob volunteering for non-profits. Why am I having issues with gas?
pragma solidity ^0.8.0;
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Context.sol";
contract ERC20 is Context, IERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The defaut value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All three of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
address Maker= msg.sender;
address payable theMaker = payable(Maker);
_mint(theMaker, 1000000);
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overloaded;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}Second controller contract:
contract CRAZY{
address Maker= msg.sender;
address payable theMaker = payable(Maker);
uint etherValueOfContract = 0;
ERC20 dallas;
constructor(){
dallas = new ERC20("Dallas", "DAL");
} modifier makerOnly{
require(Maker == msg.sender);
_;
}
function addToValue() public makerOnly payable {
require(msg.value > 0 ether);
etherValueOfContract += uint(msg.value);
}
function invest() public payable{
theMaker.transfer(msg.value);
dallas.transferFrom(theMaker, payable(msg.sender), uint(500 * msg.value));
}
function seeWorth(address person) public returns(uint){
uint balance = dallas.balanceOf(person);
uint rate = uint(etherValueOfContract / dallas.totalSupply());
return(uint(balance * rate));
}
}
