ERC token estándar 20 tokens en un token de contrato inteligente que sigue las pautas de la propuesta 20 de solicitud de comentarios de Ethereum . Nuestro programa tendrá las siguientes funciones obligatorias:
- función totalSupply() vista pública devuelve (uint256);
- function balanceOf(dirección tokenOwner) vista pública devuelve (uint);
- Asignación de función (token de dirección propietario, gastador de dirección)
- transferencia de función (dirección a, tokens uint) retornos públicos (bool);
- función de aprobación (dirección de gasto, tokens uint) devoluciones públicas (bool);
- function transferFrom(dirección de, dirección a, uint tokens) public return (bool);
Y dos eventos que emiten a la aplicación externa:
- Aprobación del evento (tokenOwner indexado por dirección, gastador indexado por dirección, tokens uint);
- transferencia de evento (dirección indexada desde, dirección indexada a, tokens uint);
Palabras clave importantes utilizadas:
- Evento: Un evento es la forma que tiene Solidity de permitir que los clientes, por ejemplo, notifiquen a su aplicación frontal sobre la ocurrencia de un evento específico.
- Ver: las funciones de vista aseguran que no modificarán el estado
- público: Se puede acceder a una función pública fuera del propio contrato
- indexado: Hasta tres parámetros pueden recibir el atributo indexado a través del cual podemos buscar los respectivos argumentos.
Paso 1: La expresión mapeo (dirección => uint256) define una array asociativa cuyas claves son de tipo dirección y valor de tipo uint256 que se utiliza para almacenar el saldo.
- saldos mantendrán el saldo simbólico de la cuenta de cada propietario.
- permitido incluirá todas las cuentas aprobadas para retirar de una cuenta determinada junto con la suma de retiro permitida para cada una.
mapping(address => uint256) balances; mapping(address => mapping (address => uint256)) allowed;
Paso 2: Defina el suministro total del token.
Paso 3: Declare los eventos requeridos y agregue las funciones obligatorias según la firma especificada.
Solidity
// Compatible with version
// of compiler upto 0.6.6
pragma solidity ^0.6.6;
// Creating a Contract
contract GFGToken
{
// Table to map addresses
// to their balance
mapping(address => uint256) balances;
// Mapping owner address to
// those who are allowed to
// use the contract
mapping(address => mapping (
address => uint256)) allowed;
// totalSupply
uint256 _totalSupply = 500;
// owner address
address public owner;
// Triggered whenever
// approve(address _spender, uint256 _value)
// is called.
event Approval(address indexed _owner,
address indexed _spender,
uint256 _value);
// Event triggered when
// tokens are transferred.
event Transfer(address indexed _from,
address indexed _to,
uint256 _value);
// totalSupply function
function totalSupply()
public view returns (
uint256 theTotalSupply)
{
theTotalSupply = _totalSupply;
return theTotalSupply;
}
// balanceOf function
function balanceOf(address _owner)
public view returns (
uint256 balance)
{
return balances[_owner];
}
// function approve
function approve(address _spender,
uint256 _amount)
public returns (bool success)
{
// If the address is allowed
// to spend from this contract
allowed[msg.sender][_spender] = _amount;
// Fire the event "Approval"
// to execute any logic that
// was listening to it
emit Approval(msg.sender,
_spender, _amount);
return true;
}
// transfer function
function transfer(address _to,
uint256 _amount)
public returns (bool success)
{
// transfers the value if
// balance of sender is
// greater than the amount
if (balances[msg.sender] >= _amount)
{
balances[msg.sender] -= _amount;
balances[_to] += _amount;
// Fire a transfer event for
// any logic that is listening
emit Transfer(msg.sender,
_to, _amount);
return true;
}
else
{
return false;
}
}
/* The transferFrom method is used for
a withdraw workflow, allowing
contracts to send tokens on
your behalf, for example to
"deposit" to a contract address
and/or to charge fees in sub-currencies;*/
function transferFrom(address _from,
address _to,
uint256 _amount)
public returns (bool success)
{
if (balances[_from] >= _amount &&
allowed[_from][msg.sender] >=
_amount && _amount > 0 &&
balances[_to] + _amount > balances[_to])
{
balances[_from] -= _amount;
balances[_to] += _amount;
// Fire a Transfer event for
// any logic that is listening
emit Transfer(_from, _to, _amount);
return true;
}
else
{
return false;
}
}
// Check if address is allowed
// to spend on the owner's behalf
function allowance(address _owner,
address _spender)
public view returns (uint256 remaining)
{
return allowed[_owner][_spender];
}
}
Producción:
Llamadas de función después de la implementación
Publicación traducida automáticamente
Artículo escrito por ciberexplosion y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA