I know what they are but I don't quite understand the raw fundamentals of how they're expressed, recorded, and sent on the blockchain.
If tokens are just smart contracts, then how do you send them exactly? How do those token transactions get recorded on the blockchain? What are the raw fundamentals of how a token is created from a smart contract?
Token balance of an address is recorded on the token contract. A token contract is considered a contract that meets all criteria required by the ERC-20 standard, such as implementing the specified interface and emitting events when required by the standard.
Balances are mostly stored in the form of a mapping where the key is the holder address, and the value is the amount of tokens they own, because it's convenient for most cases. However the standard does not specify and particular way so if it suits your needs, you can store the balances in an array, or any other way.
Token transfer is an interaction with the token contract transfer() function (standardized in ERC-20), which should perform validations (my example skips that for simplicity), update the local variables storing balances, and emit the (again standardized) Transfer event.
Offchain apps, such as Etherscan, can listen to these events and update their own database of token holders. This allows them to filter all tokens by an address in their own database and show them on the website. But again, this is not part of the blockchain data, it's an aggregated database built on top of blockchain.
Example: Address 0x123 owns 1 USDT and 2 DAI. The USDT balance is stored in the USDT contract, and the DAI balance is stored in the DAI contract. There's no global property of the 0x123 address keeping track of its tokens.
contract USDT {
// for the key `0x123`, the value is 1 (and decimals)
mapping (address => uint256) balances;
event Transfer(address indexed from, address indexed to, uint256 amount);
function transfer(address to, uint256 amount) public {
balances[msg.sender] -= amount;
balances[to] += amount;
emit Transfer(msg.sender, to, amount);
}
}
contract DAI {
// for the key `0x123`, the value is 2 (and decimals)
mapping (address => uint256) balances;
}
For a full code example, see the OpenZeppelin implementation, and their docs related to this specific implementation. Just to clarify, OpenZeppelin is an organization that publishes open source code, but you can also build your own implementation of the standard or use another one, if that fits your use case.
Related
Source code:
/**
* #dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* #dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_safeTransfer(from, to, tokenId, data);
}
Hi everyone.
While reading the Openzeppelin ERC-721 source code, I found that it defined two safeTransferFrom method with different implementations.
I am curious why it's made in this way. Could anyone help me with it?
Many thanks.
It follows the ERC-721 standard that also defines two functions with the same name - but with different input params. Generally in OOP, this is called function overloading.
As you can see in the OpenZeppelin implementation, when you call the function without the data param, it passes an empty value.
I can't speak for the authors of the standard, but to me it seems like a more developer friendly approach compared to having to explicitly pass the empty value, since Solidity doesn't allow specifying a default param value.
Best Practice Advice:
Is it acceptable to override the totalSupply() of an ERCToken if you're using a different variable to hold some of the supply and not holding all the tokens in the totalSupply variable directly?
example:
...
uint _extraSupplyForGivingAway = 1e27; //decimal 1e18 * 1M just an example
function totalSupply() public view override returns(uint totalSupply){
totalSupply = super.totalSupply() + _extraSupplyForGivingAway);
return (totalSupply);
}
The total value of the contract is not only the _totalSupply, it's also the _totalSupply and the extra tokens.
Question: Does the community and/or exchanges find this acceptable or not?
There are two different issues here. One is, are you conforming to the EIP-20 (ERC-20) standard in a way that will be understood by the community-at-large? Another is, is this a reasonable implementation for your business logic?
The latter issue is out-of-scope here since you haven't really provided enough information. So I will address the first, which is what I believe you wanted to know.
The reason I spell this out is because you fixate on implementation details but ERC20 is an interface standard, so it doesn't by-and-large dictate how things ought to be implemented.
In the case of totalSupply, all the standard says is:
totalSupply
Returns the total token supply.
function totalSupply() public view returns (uint256)
If it's not clear what that means, the EIP does link to the OpenZeppelin contract as an example implementation, which has:
/**
* #dev Total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
So as long as the total number of minted tokens is returned, you are fine. It doesn't matter if you internally have it computed as the sum of two other private variables. I do have some lingering doubts about your implementation from what you wrote, but as I said, that's out-of-scope :)
I hesitate to add this and possibly muddy the waters but.. "tokens in existence" is somewhat ambiguous. Sometimes people have their burn function do an actual transfer to the zero address (not just the event), effectively removing them from the circulating supply, and adjust the total supply accordingly. So their totalSupply will then return the number of tokens held only by non-zero addresses. Block explorers may or may not account for this. I would avoid doing this unless you absolutely know what you're doing.
I have an interesting use case that I can't seem to solve.
Problem: Tokens get X points per day. I want to freeze ERC721 tokens (they have IDs) for a certain period of time. During that time, they get 0 points per day.
I have the following to calculate points:
uint32 public constant SECONDS_IN_DAY = 1 days;
struct UserInfo {
uint256 itemCount;
uint256 pendingPoints;
uint256 lastUpdate;
}
mapping(address => UserInfo) public userInfo;
function pending(address account) public view returns (uint256) {
uint256 pendingPoints = userInfo[account].pendingPoints + (((block.timestamp - userInfo[account].lastUpdate) / SECONDS_IN_DAY) * (userInfo[account].itemCount));
return pendingPoints;
}
modifier updatePoints(address account) {
userInfo[account].pendingPoints = pending(account);
userInfo[account].lastUpdate = block.timestamp;
_;
}
The problem I can't figure out:
How do I store when each token is freezed for how long so that I can accurately determine when to reduce points in the pending function.
Do this in a gas efficient way.
I've thought about adding a mapping that holds a timestamp and the amount per day that gets reduced in UserInfo struct but then I would have no way to retrieve this information.
mapping(uint256 => uint256) perDayPointDeductions;
What can I try next?
Maybe something like snapshots or/and a chainlink keeper could be a reliable solution to this problem, and maybe you could check how some staking mechanism works since the problem you are facing is similar staking
I'm not sure if I understand the issue well, but in this case I would store the data offchain e.g. tools https://thegraph.com/en/
Where I would emit events in functions that would just store my data on TheGraph. From there I can then read this data and determine what happens to the tokens and when they will be frozen. (Gas Efficient)
But if you need to do this directly in the contract ( hence avoiding the offchain). I would go for https://docs.chain.link/docs/chainlink-keepers/introduction/
I wanted to create a smart contract that only interacts with a specific NFT. I know there is a "tokenID" attribute I don't think this is unique. Cronoscan shows multiple collections that have the same tokenIDs. Does anyone know if smart contracts can filter based on a contract address? I'd like to accomplish this with as little gas as possible.
Sorry if this is a basic question but I've Googled and searched this message board for the answer but was not able to find on other that someone trying to sell their service.
I Google and search Stack Overflow but could not find an answer.
Yes, each contract will have their own set of ids and therefore they are not unique between contracts only unique for each contract.
This checks if the code size for the address is > 0. This will have to be implemented on a new contract or you will have to find an existing contract with this functionality to view/execute it
function isContract(address addressValue) public view returns (bool) {
uint size;
assembly { size := extcodesize(addressValue) }
return size > 0;
}
Also notice this is a view function and for that reason wont cost any gas to execute.
In regards to someone selling it as a service, you can get it yourself by just deploying this contract on whatever main net you want (by the sounds of it Cronos).
'// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
contract ContractIdentifier{
function isContract(address addressValue) public view returns (bool) {
uint size;
assembly { size := extcodesize(addressValue) }
return size > 0;
}
}
I know the nft is minting through a smart contract into the blockchain. But where is the owner wallet stored? and also changing the owner requires additionl smart contract?
Owner address of each token is stored in its collection contract.
The ERC-721 standard only defines that the owner should be retrievable by calling the ownerOf() function, passing it the token ID as the only argument. It doesn't define how exactly the information should be stored.
But many implementations use a mapping. For example the OpenZeppelin implementation:
mapping(uint256 => address) private _owners;
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
changing the owner requires additionl smart contract?
Assuming the collection contract follows the standard, it's able to change the token owner (i.e. transfer the token) by executing any of the transfer functions from the owner's (non-contract) address.
So it doesn't require an additional smart contract to transfer a token.