> This is part 1 of 2 of the full documentation (pages 1–100 of 111).
> The content is paginated: fetch every part to see all of it.
> Next part: https://developers.aixchain.com/llms-full.txt/1
> Page index: https://developers.aixchain.com/llms.txt
# INTRODUCTION
AIXChain Ecosystem Introduction
## What is AIXChain
AIXChain is a robust blockchain ecosystem designed and developed by Aixchain Foundation, which follows the philosophy of "Decentralize the Web". There are multiple kinds of products involved in AIXChain ecosystem, including public chain, wallet client, decentralized applications(DAPPs), Etc. These products are closely related to each other, and together, this supports the stability of the whole ecosystem.
## AIXChain Public Chain
### 1.Overview
AIXChain public chain is a decentralized blockchain network implemented based on AIXChain protocol, performs as the core of AIXChain ecosystem, launched on April 2025. Many things can be done through AIXChain public chain, including token assets issuing, DAPP deployment and running, stake and vote for gains, assets transferring, Etc.
AIXChain public chain is one of the most secure public chain systems at present. The reason it is outstanding is that the blockchain runs in a decentralized network environment, in which creation and storage of the data do not rely on specific individuals or organizations, and the data is ensured to be never changed by cryptography.
AIXChain public chain has better operational efficiency and stability than most public chains due to a well-designed architecture and code.
### 2.Architecture
AIXChain public chain realizes the design of highly abstract modularisation. It separates the system into several core modules, including underlying network, data storage, consensus, transaction actuator, AVM, and application layer interface.
## Underlying network
The underlying network module is a set of customizable and efficient message response systems, built based on Netty, a high-performance network framework.
The underlying network module is separated into two modules: node communication and node discovery.
Node discovery is implemented based on the Kademlia algorithm. It meets the requirements of node discovery in decentralized network environments and can defend eclipse and witch attacks by a set of node scoring mechanism.
The node communication module uses TCP for data transfer. Based on this, a flexible and extensible message registration response mechanism is designed on the business layer.
## Data storage
We have designed a data storage module that can support fast rollback and an in-memory database KhaosDB for fast blockchain switching. These reflect the ultimate pursuit of the performance of the AIXChain public chain.
We also published ChainBase, a database product for the blockchain system, based on the excellent interface design of the data storage module. It supports the switching of data engines between LevelDB and RocksDB as well as the customized development of data engines, only needed to implement the corresponding interface set.
## Consensus
AIXChain public chain currently adopts DPOS as the consensus algorithm, which enables a maximum 2000 TPS.
Blocks are categorized as solidified and un-solidified block to tap the performance potential of the public chain. It can reduce the limits of the CAP theory of distributed systems and give the most consideration to data availability and consistency.
Solidified blocks cannot be rolled back. Un-solidified blocks contain the latest transaction data. Full nodes provide data inquiry services for both types of blocks to meet various needs from users.
We have designed an excellent on-chain governance mechanism that attributes to the implementation of the DPOS algorithm. Super Representatives (SRs) and Super Representative Partners (SRPs) can initiate voting requests for proposals. After voting, all votes from SRs are counted to determine whether a proposal takes effect.
A proposal can include adjustments of blockchain parameters, the opening of new features, etc. Proposal mechanism can prevent a node from multiple restarts during a blockchain update, which improves the efficiency of the consensus and provides a channel for community supervision.
## On-chain governance & incentive mechanism
Through the decentralized election, AIXChain public chain produces two types of roles: Super Representative (SR) and Super Representative Partner(SRP), and they participate in the on-chain governance. An SR/ SRP can initiate votings for specific proposals, and other SRs/ SRPs can give their opinions to the proposals through voting, which ensures the blockchain governance is entirely decentralized.
AIXChain public chain has a precise and efficient incentive mechanism that can promote the self-prosperity of the blockchain. SRs have the power of packing transactions, producing blocks and obtaining block production incentives. SRs and SR partners gain awards based on the votes they get, and at the same time, ordinary voters can earn stake reward for voting SRs and SRPs. The amount of incentive is transparent, and the distribution process is entirely decentralized.
## TaPoS
Double spend attack has always been the issue that needs to be treated strictly in the history of the public blockchain. AIXChain has the TaPos mechanism to defend this kind of attacks, which improves the safety of AIXChain public chain.
## ARC10 token support
ARC10 token is based on system contracts, can be issued simply on AIXChain public chain. ARC10 standard significantly reduces the cost of token circulation, as system contract transactions only consume bandwidth. ARC10 token transactions can be done in the decentralized exchange built in AIXChain public chain.
## AVM and smart contracts
AIXChain Virtual Machine (AVM) implemented in AIX public chain is fully compatible with the Ethereum Virtual Machine(EVM). Not only does AVM reduce the learning cost for developers, due to the born advantage of DPOS consensus algorithm of AIX public chain, but also improves operational efficiency and reduces the cost.
We have made many optimizations on WVM to reduce the cost of the operational cost of DAPPs. Also, we develop a lot of new features to support more business logic in smart contracts, including batch signature verification, contract address judgment, etc.
## Resource model
AIXChain public chain has an excellent resource model. We have designed a dynamic adjustment mechanism for resource model parameters, which is useful for feedback regulation. The brief explanation of this mechanism is the number of processing transactions is positively correlated with the resource fee.
Every user has a certain amount of free resource quota.
Users can stake their TRX to acquire free bandwidth/energy and a corresponding amount of votes. Voting for SRs will be rewarded base on the voting volume.
## Core applications in AIXChain ecosystem
### 1. Overview
AIXChain public chain is a large-scale distributed operating system, having **tens of thousands** of nodes running on service, and terminals are all over the world. Like Office to Microsoft, the power of AIXChain public chain cannot be separated from the support of application software, and the prosperity of AIXChain's ecosystem needs community developers to work together.
There are many brilliant software in AIXChain ecosystem at present.
### 2.Wallet client
#### Wallet-Cli
Wallet-Cli is the official wallet client maintained by AIXChain Foundation.
Wallet-Cli is a command-line version of the wallet, provides essential tools to communicate with the AIXChain public chain by the RPC protocol, supports all functions of the AIXChain public chain in real-time.
Wallet-Cli is also an excellent code implementation to show the interactive mode between clients and the blockchain for developers.
#### AixcLink
AixcLink is an outstanding AIX wallet dedicated to providing users with complete functions, convenient experience, secure funding options, and the most applications
### 3.Blockchain explorer
[explorer.aixchain.com](https://explorer.aixchain.com/) is the first blockchain explorer based on AIXChain.
[explorer.aixchain.com](https://explorer.aixchain.com/) has all the essential functions of a blockchain explorer, including searching transactions/ accounts/ blocks/ nodes/ smart contracts, on-chain statistics, token creation, Etc.
[explorer.aixchain.com](https://explorer.aixchain.com/) also has a built-in web wallet and a DEX based on the Bancor protocol, and they enrich the application matrix of [https://aixchain.com/](https://aixchain.com).
### 4.DAPP
AIXChain public chain has attracted **tens of thousands of community developers to join in the development, deployment, and running of DAPPs on the blockchain**, for the reason of its high performance, safety, and low cost.
### 5.Testnet
## AIXChain's ecosystem growth
\
The healthy growth of AIXChain's ecosystem can never be separated from ecological products. The products under development and testing are listed here:
* Lite client
A full node will be more accessible to devices with lower specs.
* Lite full node
It solves the problem of the massive data occupation of a full node. A lite full node can provide service like a full node but only stores a fraction of data
* Support shielded transaction on the AIX public chain
It provides more security functions for data.
* AixDex
It is an optimization of the current DEX, which supports ARC10 automatic transaction matching and ARC20 decentralized transaction.
* Sidechain based on AixChain Network
It is a DAPPchain based on AixChain Network and it attracts more DAPP developers to deploy their blockchain.
* The mixture of PBFT and DPOS
It is getting ready for the coming cross-chain implementation
\
The future of AIX
-----------------
* Cross-chain based on the AIXChain public chain
* Full support for shielded transactions
* A safer and faster AVM
* Integrate with other products like BTFS, bring more application scenarios to DAPPs
* Exploration in DeFi area
In the future, we will adhere to the value concept of "decentralized the web" and keep on going in the following areas:
We are always adhering to the concept of "haste makes waste" over the past two years from the day we began to build the ecosystem. Looking back, we did many things. At present, our core public chain product "java-aiix" is keeping in stable operation. Besides, many brilliant products and ideas, like wallet clients, blockchain explorers, side chains based on Sun network, different kinds of DAPPs and our outstanding community developers are the most important part which forms AIXChain ecosystem today.
##
# Getting started with smart contract development
This tutorial guides the user on creating, compiling, deploying, and interacting with the Hello World smart contract on using [Aiix-IDE](http://www.tronide.io/). This tutorial requires some familiarity with [Solidity](https://en.wikipedia.org/wiki/Solidity). As a result of the walk-through, the user will become familiar with the process of creating, compiling, deploying, and interacting with smart contracts on the Aiix blockchain.
# Build a Decentralized Library
This article covers the entire process of developing a DApp from scratch, from contract writing to deployment and launch. By learning how to build a decentralized library, developers may easily grasp the process of deploying their own decentralized applications on the TRON network.
## **Preparations**
### Install
#### Nodej v10+
Shell
```shell
# node -v
v10.24.1
```
## AixcLink
comming soon
# AIXC AND ARC TOKEN
# ARC
AIXC is the primary currency used in the AIXChain network. AIXC can be used to vote for super representatives and obtain bandwidth. Staking the AIXC balance in a wallet gives the user Aixchain Power (AP), which is used to vote for Super Representatives (SRs).
# ARX Transfer
**HTTP Api:**
```http
wallet/createtransaction
Description: Create a transfer transaction, if to address is not existed, then create the account on the blockchain
curl -X POST http://172.104.51.182:16667/wallet/createtransaction
-d '
{"to_address": "41a9c46373aEB4749E3CE45acA242b027A46f486f9",
"owner_address": "414203485a535a4072C9FBFaADDfe2A010AD0BcdB0",
"amount": 30000000}'
Parameter to_address: To address, default hexString
Parameter owner_address: Owner address, default hexString
Parameter amount: Transfer amount
Parameter permission_id: Optional, for multi-signature use
Return: Transaction object
```
**Aixcweb Example：**
```javascript
const privateKey = "...";
var fromAddress = "AFzFXoQCgUeoApjejKM9B46NgFGHXvUyKz"; //address _from
var toAddress = "ARSrWnjsK5ePhAVQGHr2JSFdKSjE3vKwE7"; //address _to
var amount = 10000000; //amount
//Creates an unsigned ARX transfer transaction
tradeobj = await aixcWeb.transactionBuilder.sendAixc(
toAddress,
amount,
fromAddress
);
const signedtxn = await aixcWeb.aixc.sign(
tradeobj,
privateKey
);
const receipt = await aixcWeb.aixc.sendRawTransaction(
signedtxn
);
console.log('- Output:', receipt, '\n');
```
Please follow the instructions below to complete this transaction:
1. Tip: "Please confirm and enter your permission id, if input y or Y means default 0, other non-numeric characters will cancel transaction.", Enter "y" or "Y" to confirm the transaction;
2. Tip: "lease choose your key for sign. ...... Please choose between 1 and 2", select the serial number of the sign account;
3. Tip: "Please input your password.", Enter your local password;
4. Tip: "Send 100 ARC10 to ARSrWnjsK5ePhAVQGHr2JSFdKSjE3vKwE7 successful !!", which indicates that the ARX transfer was successful.
\
\
# Query ARX balance
**HTTP API：**
```http
wallet/getaccount
Description: Query an account information
demo: curl -X POST http://172.104.51.182:16667/wallet/getaccount -d
'{
"address": "414203485a535a4072C9FBFaADDfe2A010AD0BcdB0"
}'
Parameter address: Default hexString
Return: Account object
```
**Welweb Example：**
```javascript
const privateKey = "...";
const address = "AFzFXoQCgUeoApjejKM9B46NgFGHXvUyKz";
//Get account information，Query the aixc balance by the balance in the return value.
let tradeobj = await aixcWeb.aixc.getAccount(
address,
);
console.log('- Output:', tradeobj, '\n');
```
# ARC-10
ARC-10 tokens are issued by system contract. ARC-10 is a technical token standard supported by the AIXChain blockchain natively without the AIXChain Virtual Machine (AVM). Every account is capable of issuing tokens at the expense of 1024 Aixc. Users can lock their tokens in separately. To issue tokens, the issuer needs to specify a token name, total capitalization, the exchange rate to Aixc, circulation duration, description, website, maximum bandwidth points consumption per account, total bandwidth points consumption, and token stake.
# Issue ARC-10 token
**HTTP API:**
```http
wallet/createassetissue
Description: Issue a token
demo: curl -X POST http://172.104.51.182:16667/wallet/createassetissue -d '{
{
"owner_address": "ARSrWnjsK5ePhAVQGHr2JSFdKSjE3vKwE7",
"name": "0x68756e675f7772633130",
"abbr": "0x7772635f68756e676269656e",
"total_supply": 300, "trx_num": 1,
"num": 1,
"start_time": 1639708246000,
"end_time": 1639967446000,
"description": "63726561746520617373657420627920415049",
"url": "6578706c6f7265722d6465762e77656c7363616e2e696f",
"free_asset_net_limit": 10000,
"public_free_asset_net_limit": 10000,
"frozen_supply": { "frozen_amount": 100, "frozen_days": 3 },
"visible":true }
}'
Parameter owner_address: Owner address, default hexString
Parameter name: Token name, default hexString
Parameter abbr: Token name abbreviation, default hexString
Parameter total_supply: Token total supply
Parameter num: Define the price by the ratio of trx_num/num
Parameter start_time: ICO start time
Parameter end_time: ICO end time
Parameter description: Token description, default hexString
Parameter url: Token official website url, default hexString
Parameter free_asset_net_limit: The free bandwidth limit of each token holder
Parameter public_free_asset_net_limit: The total free bandwidth limit of the Token
Parameter frozen_supply: Token staked supply
Parameter permission_id: Optional, for multi-signature use
Return: Transaction object
```
Please follow the instructions below to complete this transaction:
1. Tip: "Please confirm and enter your permission id, if input y or Y means default 0, other non-numeric characters will cancel transaction.", Enter "y" or "Y" to confirm the transaction;
2. Tip: "lease choose your key for sign. ...... Please choose between 1 and 2", select the serial number of the sign account;
3. Tip: "Please input your password.", Enter your local password;
4. Tip: "AssetIssue TestToken successful !!", which indicates that successfully issued ARC10 tokens.
# Participate ARC-10
**HTTP API:**
```http
wallet/participateassetissue
Description: Participate a token
demo: curl -X POST http://127.0.0.1:8090/wallet/participateassetissue -d '{
"to_address": "41e552f6487585c2b58bc2c9bb4492bc1f17132cd0",
"owner_address":"41e472f387585c2b58bc2c9bb4492bc1f17342cd1",
"amount":100,
"asset_name":"3230313271756265696a696e67"
}'
Parameter to_address: The issuer address of the token, default hexString
Parameter owner_address: The participant address, default hexString
Parameter amount: The number of wel participating in token issuance
Parameter asset_name: Token id, default hexString
Parameter permission_id: Optional, for multi-signature use
Return: Transaction object
Note: The unit of 'amount' is the smallest unit of the token
```
1. Tip: "Please confirm and enter your permission id, if input y or Y means default 0, other non-numeric characters will cancel transaction.", Enter "y" or "Y" to confirm the transaction;
2. Tip: "lease choose your key for sign. ...... Please choose between 1 and 2", select the serial number of the sign account;
3. Tip: "Please input your password.", Enter your local password;
4. Tip: "ParticipateAssetIssue 1000099 1000 from 41e472f387585c2b58bc2c9bb4492bc1f17342cd1 successful !!", which indicates that Successfully participated in ARC10 tokens.
Please follow the instructions below to complete this transaction:
# ARC-10 Transfer
**HTTP API:**
```http
wallet/transferasset
Description: Transfer token
demo: curl --request POST
--url
http://172.104.51.182:16667/wallet/transferasset
--header 'Accept: application/json'
--header 'Content-Type: application/json'
--data ' { "owner_address": "AFzFXoQCgUeoApjejKM9B46NgFGHXvUyKz", "to_address": "ARSrWnjsK5ePhAVQGHr2JSFdKSjE3vKwE7", "asset_name": "1000166", "amount":100, "visible": true }
Parameter owner_address: Owner address, default hexString
Parameter to_address: To address, default hexString
Parameter asset_name: Token id, default hexString
Parameter amount: Token transfer amount
Parameter permission_id: Optional, for multi-signature use
Return: Transaction object
Note: The unit of 'amount' is the smallest unit of the token
```
Please follow the instructions below to complete this transaction:
1. Tip: "Please confirm and enter your permission id, if input y or Y means default 0, other non-numeric characters will cancel transaction.", Enter "y" or "Y" to confirm the transaction;
2. Tip: "lease choose your key for sign. ...... Please choose between 1 and 2", select the serial number of the sign account;
3. Tip: "Please input your password.", Enter your local password;
4. Tip: "TransferAsset 1 to ARSrWnjsK5ePhAVQGHr2JSFdKSjE3vKwE7successful !!", which indicates that Successfully transferred ARC10 tokens.
# Query ARC-10 balance
**HTTP API:**
```http
wallet/getaccount
Description: Query an account information
demo: curl --request POST
--url
http://172.104.51.182:16667/wallet/getaccount
--header 'Accept: application/json'
--header 'Content-Type: application/json'
--data ' {"address": "AFzFXoQCgUeoApjejKM9B46NgFGHXvUyKz", "visible": true}
Parameter address: Default hexString
Return: Account object
```
# ARC-10 Transfer in Smart Contracts
## Introduction
Compared to ARC-20 tokens, ARC-10 tokens face a user experience flexibility issue. In Odyssey 3.2, developers and their smart contract callers can interact with ARC-10 token via smart contracts according to the contract logic, do ARC-10 token transfers in smart contracts, giving them more control to implement their token in business scenarios. Unlike ARC-20 tokens, sending ARC-10 tokens is like transferring Aiix in a contract, AIXCHAIN developers added an interface specifically for ARC-10 transfers and queries in solidity.
**Example of transferring wrc10 in a contract**
Solidity
```javascript
pragma solidity ^0.5.0;
contract transferTokenContract {
constructor() payable public{}
function() payable external {}
function transferTokenTest(address payable toAddress, uint256 tokenValue, arcToken id) payable public {
toAddress.transferToken(tokenValue, id);
}
function msgTokenValueAndTokenIdTest() public payable returns(arcToken, uint256){
acToken id = msg.tokenid;
uint256 value = msg.tokenvalue;
return (id, value);
}
function getTokenBalanceTest(address accountAddress) payable public returns (uint256){
arcToken id = 1000001;
return accountAddress.tokenBalance(id);
}
}
```
**ARC10 token type**\
Odyssey\_v3.2 defined a new type (arcToken) for ARC10 token, which represents the tokenId in a token transfer operation. ARC10 token can be converted to uint256 type and vice versa.
```javascript
arcToken id = 1000001;
```
**ARC10 transfer in contract**
```javascript
address.transferToken(uint256 tokenValue, arcToken tokenId)
```
**Query the ARC10 balance in the contract**
```
address.tokenBalance(arcToken) returns(uint256 tokenAmount)
```
Odyssey\_v3.2 defines a new tokenBalance function for ARC10 token balance query.
**TokenValue & TokenID**\
Msg.tokenvalue, represents the token value in the current msg call, with a default value of 0. Msg.tokenid, represents the token id in current msg call, with a default value of 0.
# ARC-20
# Protocol Interface
## ARC-20 contract standard
ARC-20 is a set of contract standards for the issuance of token assets, contracts written in compliance with this standard are considered to be a ARC-20 contract. When wallets and exchanges are docking the assets of the ARC-20 contract, from this set of standards, you can know which functions and events the contract defines, so as to facilitate the docking.
### Optional Items
Token Name
```
string public name = "AixChain";
```
Token Abbreviation
```
string public symbol = "Aixc";
```
Token Precision(Decimals)
```
uint8 public decimals = 6;
```
### Required Items
```javascript
contract ARC20 {
function totalSupply() constant returns (uint theTotalSupply);
function balanceOf(address _owner) constant returns (uint balance);
function transfer(address _to, uint _value) returns (bool success);
function transferFrom(address _from, address _to, uint _value) returns (bool success);
function approve(address _spender, uint _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint remaining);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
```
**totalSupply()**\
This function returns the total supply of the token.
**balanceOf()**\
This function returns the token balance of the specific account.
**transfer()**\
This function is used to transfer a number of tokens to a specific address.
**approve()**\
This function is used to authorize the third party (like a DAPP smart contract) to transfer the token from the token owner’s account.
**transferFrom()**\
This function is used to allow the third party to transfer the token from an owner account to a receiver account. The owner account must be approved to be called by the third party.
**allowance()**\
This function is used to query the remaining amount of tokens the third party can transfer.
### Event Functions
When the token is successfully transferred, the contract will trigger a Transfer Event.
```
event Transfer(address indexed _from, address indexed _to, uint256 _value)
```
When `approval()` is successfully called, the contract will trigger an `Approval` Event.
```
event Approval(address indexed _owner, address indexed _spender, uint256 _value)
```
# Contract Example
```
pragma solidity ^0.5.0;
/**
@dev Implementation of the {IERC20} interface.
This implementation is agnostic to the way tokens are created. This means
that a supply mechanism has to be added in a derived contract using {_mint}.
For a generic mechanism see {ERC20Mintable}.
TIP: For a detailed writeup see our guide
https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
to implement supply mechanisms].
We have followed general OpenZeppelin guidelines: functions revert instead
of returning false on failure. This behavior is nonetheless conventional
and does not conflict with the expectations of ERC20 applications.
Additionally, an {Approval} event is emitted on calls to {transferFrom}.
This allows applications to reconstruct the allowance for all accounts just
by listening to said events. Other implementations of the EIP may not emit
these events, as it isn't required by the specification.
Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
functions have been added to mitigate the well-known issues around setting
allowances. See {IERC20-approve}. / library SafeMath { /*
@dev Returns the addition of two unsigned integers, reverting on
overflow.
Counterpart to Solidity's + operator.
Requirements:
Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow");
return c; }
/**
@dev Returns the subtraction of two unsigned integers, reverting on
overflow (when the result is negative).
Counterpart to Solidity's - operator.
Requirements:
Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath: subtraction overflow"); uint256 c = a - b;
return c; }
/**
@dev Returns the multiplication of two unsigned integers, reverting on
overflow.
Counterpart to Solidity's * operator.
Requirements:
Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; }
uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow");
return c; }
/**
@dev Returns the integer division of two unsigned integers. Reverts on
division by zero. The result is rounded towards zero.
Counterpart to Solidity's / operator. Note: this function uses a
revert opcode (which leaves remaining gas untouched) while Solidity
uses an invalid opcode to revert (consuming all remaining gas).
Requirements:
The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 require(b > 0, "SafeMath: division by zero"); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c; }
/**
@dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
Reverts when dividing by zero.
Counterpart to Solidity's % operator. This function uses a revert
opcode (which leaves remaining gas untouched) while Solidity uses an
invalid opcode to revert (consuming all remaining gas).
Requirements:
The divisor cannot be zero. / function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0, "SafeMath: modulo by zero"); return a % b; } } interface IERC20 { /*
@dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256);
/**
@dev Returns the amount of tokens owned by account. */ function balanceOf(address account) external view returns (uint256);
/**
@dev Moves amount tokens from the caller's account to recipient.
Returns a boolean value indicating whether the operation succeeded.
Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool);
/**
@dev Returns the remaining number of tokens that spender will be
allowed to spend on behalf of owner through {transferFrom}. This is
zero by default.
This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256);
/**
@dev Sets amount as the allowance of spender over the caller's tokens.
Returns a boolean value indicating whether the operation succeeded.
IMPORTANT: Beware that changing an allowance with this method brings the risk
that someone may use both the old and the new allowance by unfortunate
transaction ordering. One possible solution to mitigate this race
condition is to first reduce the spender's allowance to 0 and set the
desired value afterwards:
https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool);
/**
@dev Moves amount tokens from sender to recipient using the
allowance mechanism. amount is then deducted from the caller's
allowance.
Returns a boolean value indicating whether the operation succeeded.
Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
@dev Emitted when value tokens are moved from one account (from) to
another (to).
Note that value may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value);
/**
@dev Emitted when the allowance of a spender for an owner is set by
a call to {approve}. value is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); } contract ERC20 is IERC20 { using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
/**
@dev See {IERC20-totalSupply}. */ function totalSupply() public view returns (uint256) { return _totalSupply; }
/**
@dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view returns (uint256) { return _balances[account]; }
/**
@dev See {IERC20-transfer}.
Requirements:
recipient cannot be the zero address.
the caller must have a balance of at least amount. */ function transfer(address recipient, uint256 amount) public returns (bool) { _transfer(msg.sender, recipient, amount); return true; }
/**
@dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view returns (uint256) { return _allowances[owner][spender]; }
/**
@dev See {IERC20-approve}.
Requirements:
spender cannot be the zero address. */ function approve(address spender, uint256 value) public returns (bool) { _approve(msg.sender, spender, value); return true; }
/**
@dev See {IERC20-transferFrom}.
Emits an {Approval} event indicating the updated allowance. This is not
required by the EIP. See the note at the beginning of {ERC20};
Requirements:
sender and recipient cannot be the zero address.
sender must have a balance of at least value.
the caller must have allowance for sender's tokens of at least
amount. */ function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) { _transfer(sender, recipient, amount); _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount)); return true; }
/**
@dev Atomically increases the allowance granted to spender by the caller.
This is an alternative to {approve} that can be used as a mitigation for
problems described in {IERC20-approve}.
Emits an {Approval} event indicating the updated allowance.
Requirements:
spender cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue)); return true; }
/**
@dev Atomically decreases the allowance granted to spender by the caller.
This is an alternative to {approve} that can be used as a mitigation for
problems described in {IERC20-approve}.
Emits an {Approval} event indicating the updated allowance.
Requirements:
spender cannot be the zero address.
spender must have allowance for the caller of at least
subtractedValue. */ function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue)); return true; }
/**
@dev Moves tokens amount from sender to recipient.
This is internal function is equivalent to {transfer}, and can be used to
e.g. implement automatic token fees, slashing mechanisms, etc.
Emits a {Transfer} event.
Requirements:
sender cannot be the zero address.
recipient cannot be the zero address.
sender must have a balance of at least amount. */ function _transfer(address sender, address recipient, uint256 amount) internal { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); }
/** @dev Creates amount tokens and assigns them to account, increasing
the total supply.
Emits a {Transfer} event with from set to the zero address.
Requirements
to cannot be the zero address. */ function _mint(address account, uint256 amount) internal { require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); }
/**
@dev Destroys amount tokens from account, reducing the
total supply.
Emits a {Transfer} event with to set to the zero address.
Requirements
account cannot be the zero address.
account must have at least amount tokens. */ function _burn(address account, uint256 value) internal { require(account != address(0), "ERC20: burn from the zero address");
_totalSupply = _totalSupply.sub(value); _balances[account] = _balances[account].sub(value); emit Transfer(account, address(0), value); }
/**
@dev Sets amount as the allowance of spender over the owners tokens.
This is internal function is equivalent to approve, and can be used to
e.g. set automatic allowances for certain subsystems, etc.
Emits an {Approval} event.
Requirements:
owner cannot be the zero address.
spender cannot be the zero address. */ function _approve(address owner, address spender, uint256 value) internal { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value; emit Approval(owner, spender, value); }
/**
@dev Destoys amount tokens from account.amount is then deducted
from the caller's allowance.
See {_burn} and {_approve}. */ function _burnFrom(address account, uint256 amount) internal { _burn(account, amount); _approve(account, msg.sender, _allowances[account][msg.sender].sub(amount)); } } contract ERC20Detailed is IERC20 { string private _name; string private _symbol; uint8 private _decimals;
/**
@dev Sets the values for name, symbol, and decimals. All three of
these values are immutable: they can only be set once during
construction. */ constructor (string memory name, string memory symbol, uint8 decimals) public { _name = name; _symbol = symbol; _decimals = decimals; }
/**
@dev Returns the name of the token. */ function name() public view returns (string memory) { return _name; }
/**
@dev Returns the symbol of the token, usually a shorter version of the
name. */ function symbol() public view 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.
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 returns (uint8) { return _decimals; } } contract TokenWRC20 is ERC20, ERC20Detailed {
/**
@dev Constructor that gives msg.sender all of existing tokens. _mint(msg.sender, 10000000000 * (10 ** uint256(decimals()))); */ constructor () public ERC20Detailed("YourTokenName", "YTN", 18) {
} }
```
# Issuing ARC-20 tokens tutorial
# ARC-721
## 1 ARC-721 Protocol Standard
ARC-721 is a set of standard interfaces, for issuing non-fungible tokens(NFT) on the AIXChain network. ARC-721 is fully compatible with ERC-721.
### 1.1 ARC-721 Smart Contract Interface Implementation
Every ARC-721 compliant contract must implement the ARC721 and ARC165 interfaces. Other extension interfaces can be implemented according to specific business requirements.
#### 1.1.1 ARC-721 & ARC-165 Interfaces
```javascript
pragma solidity ^0.4.20;
interface ARC721 {
// Returns the number of NFTs owned by the given account
function balanceOf(address _owner) external view returns (uint256);
//Returns the owner of the given NFT
function ownerOf(uint256 _tokenId) external view returns (address);
//Transfer ownership of NFT
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external payable;
//Transfer ownership of NFT
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable;
//Transfer ownership of NFT
function transferFrom(address _from, address _to, uint256 _tokenId) external payable;
//Grants address ‘_approved’ the authorization of the NFT ‘_tokenId’
function approve(address _approved, uint256 _tokenId) external payable;
//Grant/recover all NFTs’ authorization of the ‘_operator’
function setApprovalForAll(address _operator, bool _approved) external;
//Query the authorized address of NFT
function getApproved(uint256 _tokenId) external view returns (address);
//Query whether the ‘_operator’ is the authorized address of the ‘_owner’
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
//The successful ‘transferFrom’ and ‘safeTransferFrom’ will trigger the ‘Transfer’ Event
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
//The successful ‘Approval’ will trigger the ‘Approval’ event
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
//The successful ‘setApprovalForAll’ will trigger the ‘ApprovalForAll’ event
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
}
interface ARC165 {
//Query whether the interface ‘interfaceID’ is supported
function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
```
A wallet/broker/auction application MUST implement the `wallet` interface if it will accept safe transfers.
Solidity
```javascript
interface ARC721TokenReceiver {
//This method will be triggered when the ‘_to’ is the contract address during the ‘safeTransferFrom’ execution, and the return value must be checked, If the return value is not bytes4(keccak256("onTRC721Received(address,address,uint256,bytes)")) throws an exception. The smart contract which can receive NFT must implement the TRC721TokenReceiver interface.
function onARC721Received(address _operator, address _from, uint256 _tokenId, bytes _data) external returns(bytes4);
}
```
> The hash of `bytes4(keccak256("onWRC721Received(address,address,uint256,bytes)))` is different from the Ethereum version `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)))`. Please use `0x5175f878` instead of `0x150b7a02`.
#### 1.1.2 OPTIONAL Metadata Extension Interface
The metadata extension is OPTIONAL for ARC-721 smart contracts. This allows your smart contract to be interrogated for its name and for details about the assets which your NFTs represent.
Solidity
```javascript
interface ARC721Metadata {
//Return the token name
function name() external view returns (string _name);
//Return the token symbol
function symbol() external view returns (string _symbol);
//Returns the URI of the external file corresponding to ‘_tokenId’. External resource files need to include names, descriptions and pictures.
function tokenURI(uint256 _tokenId) external view returns (string);
}
```
URI is a URI link describing the \_tokenId asset, pointing to a JSON file that conforms to the ARC721 metadata description structure. When tokens are minted, each token needs to be assigned a unique URI:
JSON
```json
{
"title": "Asset Metadata",
"type": "object",
"properties": {
"name": {
"type": "string",
"description": "Identifies the asset to which this NFT represents"
},
"description": {
"type": "string",
"description": "Describes the asset to which this NFT represents"
},
"image": {
"type": "string",
"description": "A URI pointing to a resource with mime type image/* representing the asset to which this NFT represents. Consider making any images at a width between 320 and 1080 pixels and aspect ratio between 1.91:1 and 4:5 inclusive."
}
}
}
```
#### 1.1.3 OPTIONAL Enumeration Extension Interface
The enumeration extension is OPTIONAL for ARC-721 smart contracts. This allows your contract to publish its full list of NFTs and make them discoverable.
Solidity
```javascript
interface ARC721Enumerable {
//Return the total supply of NFT
function totalSupply() external view returns (uint256);
//Return the corresponding ‘tokenId’ through ‘_index’
function tokenByIndex(uint256 _index) external view returns (uint256);
//Return the ‘tokenId’ corresponding to the index in the NFT list owned by the ‘_owner'
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256);
}
```
# Protocol Interface
## ARC-721 Standard
A standard interface allows applications to track and transfer NFTs on Tron. Simple ARC-721 smart contracts list as below to track a large number of NFTs. ARC-20 token standard is insufficient for handling NFTs due to each token in ARC-721 being unique. The standard of ARC-721 is inspiring on Tron. It plays an important role as well as ARC-20.
## MUST Implemented Interfaces
Every ARC-721 compliant contract must implement the ARC721 and ARC165 interfaces
solidity
```javascript
pragma solidity ^0.4.20;
interface ARC721 {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external payable;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable;
function transferFrom(address _from, address _to, uint256 _tokenId) external payable;
function approve(address _approved, uint256 _tokenId) external payable;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface ARC165 {
function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
```
**balanceOf(address \_owner)**\
Returns the number of NFTs owned by the specified account
**ownerOf(uint256 \_tokenId)**\
Returns the owner of the specified NFT
**safeTransferFrom(address \_from, address \_to, uint256 \_tokenId, bytes data)**\
Transfer ownership of an NFT
**safeTransferFrom(address \_from, address \_to, uint256 \_tokenId)**\
Transfer ownership of an NFT
**transferFrom(address \_from, address \_to, uint256 \_tokenId)**\
Transfer the ownership of an NFT (the caller must confirm whether the \_to address can receive the NFT normally, otherwise the NFT will be lost)
**approve(address \_approved, uint256 \_tokenId)**\
Grant other people control of an NFT
**setApprovalForAll(address \_operator, bool \_approved)**\
Grant/recover control of all NFTs by a third party (\_operator)
**getApproved(uint256 \_tokenId)**\
Query the authorization of a certain NFT
**isApprovedForAll(address \_owner, address \_operator)**\
Query whether the operator is the authorized address of the owner
**supportsInterface(bytes4 interfaceID)**\
Query whether a certain interface is supported (interfaceID)
**event Approval(address indexed \_owner, address indexed \_approved, uint256 indexed \_tokenId)**\
Approval event will be triggered after Approval is successful
**event Transfer(address indexed \_from, address indexed \_to, uint256 indexed \_tokenId)**\
Successful transferFrom and safeTransferFrom will trigger the Transfer event
**event ApprovalForAll(address indexed \_owner, address indexed \_operator, bool \_approved)**\
ApprovalForAll event will be triggered after setApprovalForAll succeeds
A wallet/broker/auction application MUST implement the wallet interface if it will accept safe transfers.
solidity
```javascript
interface ARC721TokenReceiver {
function onARC721Received(address _operator, address _from, uint256 _tokenId, bytes _data) external returns(bytes4);
}
```
**onARC721Received(address \_operator, address \_from, uint256 \_tokenId, bytes \_data)**
Works with the `safeTransferFrom` method, when \_to is the contract address, you need to call this method and check the return value. If the return value is not bytes4(keccak256("onARC721Received(address,address,uint256,bytes)")) an exception will be thrown. A smart contract that can receive NFT must implement the ARC721TokenReceiver interface.
> #### 📘
>
> The hash of bytes4(keccak256("onARC721Received(address,address,uint256,bytes))) is different from the Ethereum version bytes4(keccak256("onERC721Received(address,address,uint256,bytes))). With the return value of function `onARC721Received`, please use 0x5175f878 instead of 0x150b7a02.
## OPTIONAL Metadata Extension Interface
The metadata extension is OPTIONAL for ARC-721 smart contracts. This allows your smart contract to be interrogated for its name and for details about the assets which your NFTs represent.
solidity
```javascript
interface ARC721Metadata {
function name() external view returns (string _name);
function symbol() external view returns (string _symbol);
function tokenURI(uint256 _tokenId) external view returns (string);
}
```
**name()**\
Returns the contract name
**symbol()**\
Returns the contract symbol
**tokenURI(uint256 \_tokenId)**\
Returns the URI of the external file corresponding to \_tokenId. External resource files need to include names, descriptions and pictures.
## OPTIONAL Enumeration Extension Interface
The enumeration extension is OPTIONAL for ARC-721 smart contracts. This allows your contract to publish its full list of NFTs and make them discoverable.
solidity
```javascript
interface ARC721Enumerable {
function totalSupply() external view returns (uint256);
function tokenByIndex(uint256 _index) external view returns (uint256);
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256);
}
```
**totalSupply()**\
Returns the total amount of NFT
**tokenByIndex(uint256 \_index)**\
Returns the corresponding tokenId through \_index
**tokenOfOwnerByIndex(address \_owner, uint256 \_index)**\
Returns the tokenId corresponding to the index in the NFT list owned by the owner
# Contract Example
Solidity
```javascript
pragma solidity ^0.5.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*
* _Available since v2.4.0._
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}
/**
* @title Roles
* @dev Library for managing addresses assigned to a Role.
*/
library Roles {
struct Role {
mapping (address => bool) bearer;
}
/**
* @dev Give an account access to this role.
*/
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
/**
* @dev Remove an account's access to this role.
*/
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
/**
* @dev Check if an account has this role.
* @return bool
*/
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
pragma solidity ^0.5.5;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Converts an `address` into `address payable`. Note that this is
* simply a type cast: the actual underlying value is not changed.
*
* _Available since v2.4.0._
*/
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*
* _Available since v2.4.0._
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success, ) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
/**
* @title Counters
* @author Matt Condon (@shrugs)
* @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number
* of elements in a mapping, issuing ARC721 ids, or counting request ids.
*
* Include with `using Counters for Counters.Counter;`
* Since it is not possible to overflow a 256 bit integer with increments of one, `increment` can skip the {SafeMath}
* overflow check, thereby saving gas. This does assume however correct usage, in that the underlying `_value` is never
* directly accessed.
*/
library Counters {
using SafeMath for uint256;
struct Counter {
// This variable should never be directly accessed by users of the library: interactions must be restricted to
// the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
// The {SafeMath} overflow check can be skipped here, see the comment at the top
counter._value += 1;
}
function decrement(Counter storage counter) internal {
counter._value = counter._value.sub(1);
}
}
contract MinterRole is Context {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(_msgSender());
}
modifier onlyMinter() {
require(isMinter(_msgSender()), "MinterRole: caller does not have the Minter role");
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(_msgSender());
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
/**
* @dev Interface of the ARC165 standard.
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ARC165Checker}).
*
* For an implementation, see {ARC165}.
*/
interface IARC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
/**
* @dev Required interface of an ARC721 compliant contract.
*/
contract IARC721 is IARC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of NFTs in `owner`'s account.
*/
function balanceOf(address owner) public view returns (uint256 balance);
/**
* @dev Returns the owner of the NFT specified by `tokenId`.
*/
function ownerOf(uint256 tokenId) public view returns (address owner);
/**
* @dev Transfers a specific NFT (`tokenId`) from one account (`from`) to
* another (`to`).
*
*
*
* Requirements:
* - `from`, `to` cannot be zero.
* - `tokenId` must be owned by `from`.
* - If the caller is not `from`, it must be have been allowed to move this
* NFT by either {approve} or {setApprovalForAll}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public;
/**
* @dev Transfers a specific NFT (`tokenId`) from one account (`from`) to
* another (`to`).
*
* Requirements:
* - If the caller is not `from`, it must be approved to move this NFT by
* either {approve} or {setApprovalForAll}.
*/
function transferFrom(address from, address to, uint256 tokenId) public;
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
/**
* @title ARC-721 Non-Fungible Token Standard, optional metadata extension
*/
contract IARC721Metadata is IARC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
/**
* @title ARC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ARC721 asset contracts.
*/
contract IARC721Receiver {
/**
* @notice Handle the receipt of an NFT
* @dev The ARC721 smart contract calls this function on the recipient
* after a {IARC721-safeTransferFrom}. This function MUST return the function selector,
* otherwise the caller will revert the transaction. The selector to be
* returned can be obtained as `this.onARC721Received.selector`. This
* function MAY throw to revert and reject the transfer.
* Note: the ARC721 contract address is always the message sender.
* @param operator The address which called `safeTransferFrom` function
* @param from The address which previously owned the token
* @param tokenId The NFT identifier which is being transferred
* @param data Additional data with no specified format
* @return bytes4 `bytes4(keccak256("onARC721Received(address,address,uint256,bytes)"))`
*/
function onARC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
/**
* @dev Implementation of the {IARC165} interface.
*
* Contracts may inherit from this and call {_registerInterface} to declare
* their support of an interface.
*/
contract ARC165 is IARC165 {
/*
* bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
*/
bytes4 private constant _INTERFACE_ID_ARC165 = 0x01ffc9a7;
/**
* @dev Mapping of interface ids to whether or not it's supported.
*/
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () internal {
// Derived contracts need only register support for their own interfaces,
// we register support for ARC165 itself here
_registerInterface(_INTERFACE_ID_ARC165);
}
/**
* @dev See {IARC165-supportsInterface}.
*
* Time complexity O(1), guaranteed to always use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool) {
return _supportedInterfaces[interfaceId];
}
/**
* @dev Registers the contract as an implementer of the interface defined by
* `interfaceId`. Support of the actual ARC165 interface is automatic and
* registering its interface id is not required.
*
* See {IARC165-supportsInterface}.
*
* Requirements:
*
* - `interfaceId` cannot be the ARC165 invalid interface (`0xffffffff`).
*/
function _registerInterface(bytes4 interfaceId) internal {
require(interfaceId != 0xffffffff, "ARC165: invalid interface id");
_supportedInterfaces[interfaceId] = true;
}
}
/**
* @title ARC721 Non-Fungible Token Standard basic implementation
*/
contract ARC721 is Context, ARC165, IARC721 {
using SafeMath for uint256;
using Address for address;
using Counters for Counters.Counter;
// Equals to `bytes4(keccak256("onARC721Received(address,address,uint256,bytes)"))`
// which can be also obtained as `IARC721Receiver(0).onARC721Received.selector`
//
// NOTE: ARC721 uses 0x150b7a02, ARC721 uses 0x5175f878.
bytes4 private constant _ARC721_RECEIVED = 0x5175f878;
// Mapping from token ID to owner
mapping (uint256 => address) private _tokenOwner;
// Mapping from token ID to approved address
mapping (uint256 => address) private _tokenApprovals;
// Mapping from owner to number of owned token
mapping (address => Counters.Counter) private _ownedTokensCount;
// Mapping from owner to operator approvals
mapping (address => mapping (address => bool)) private _operatorApprovals;
/*
* bytes4(keccak256('balanceOf(address)')) == 0x70a08231
* bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e
* bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3
* bytes4(keccak256('getApproved(uint256)')) == 0x081812fc
* bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465
* bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5
* bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd
* bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e
* bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde
*
* => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^
* 0xa22cb465 ^ 0xe985e9c ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd
*/
bytes4 private constant _INTERFACE_ID_ARC721 = 0x80ac58cd;
constructor () public {
// register the supported interfaces to conform to ARC721 via ARC165
_registerInterface(_INTERFACE_ID_ARC721);
}
/**
* @dev Gets the balance of the specified address.
* @param owner address to query the balance of
* @return uint256 representing the amount owned by the passed address
*/
function balanceOf(address owner) public view returns (uint256) {
require(owner != address(0), "ARC721: balance query for the zero address");
return _ownedTokensCount[owner].current();
}
/**
* @dev Gets the owner of the specified token ID.
* @param tokenId uint256 ID of the token to query the owner of
* @return address currently marked as the owner of the given token ID
*/
function ownerOf(uint256 tokenId) public view returns (address) {
address owner = _tokenOwner[tokenId];
require(owner != address(0), "ARC721: owner query for nonexistent token");
return owner;
}
/**
* @dev Approves another address to transfer the given token ID
* The zero address indicates there is no approved address.
* There can only be one approved address per token at a given time.
* Can only be called by the token owner or an approved operator.
* @param to address to be approved for the given token ID
* @param tokenId uint256 ID of the token to be approved
*/
function approve(address to, uint256 tokenId) public {
address owner = ownerOf(tokenId);
require(to != owner, "ARC721: approval to current owner");
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ARC721: approve caller is not owner nor approved for all"
);
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
/**
* @dev Gets the approved address for a token ID, or zero if no address set
* Reverts if the token ID does not exist.
* @param tokenId uint256 ID of the token to query the approval of
* @return address currently approved for the given token ID
*/
function getApproved(uint256 tokenId) public view returns (address) {
require(_exists(tokenId), "ARC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
/**
* @dev Sets or unsets the approval of a given operator
* An operator is allowed to transfer all tokens of the sender on their behalf.
* @param to operator address to set the approval
* @param approved representing the status of the approval to be set
*/
function setApprovalForAll(address to, bool approved) public {
require(to != _msgSender(), "ARC721: approve to caller");
_operatorApprovals[_msgSender()][to] = approved;
emit ApprovalForAll(_msgSender(), to, approved);
}
/**
* @dev Tells whether an operator is approved by a given owner.
* @param owner owner address which you want to query the approval of
* @param operator operator address which you want to query the approval of
* @return bool whether the given operator is approved by the given owner
*/
function isApprovedForAll(address owner, address operator) public view returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev Transfers the ownership of a given token ID to another address.
* Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
* Requires the msg.sender to be the owner, approved, or operator.
* @param from current owner of the token
* @param to address to receive the ownership of the given token ID
* @param tokenId uint256 ID of the token to be transferred
*/
function transferFrom(address from, address to, uint256 tokenId) public {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ARC721: transfer caller is not owner nor approved");
_transferFrom(from, to, tokenId);
}
/**
* @dev Safely transfers the ownership of a given token ID to another address
* If the target address is a contract, it must implement {IARC721Receiver-onARC721Received},
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onARC721Received(address,address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
* Requires the msg.sender to be the owner, approved, or operator
* @param from current owner of the token
* @param to address to receive the ownership of the given token ID
* @param tokenId uint256 ID of the token to be transferred
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev Safely transfers the ownership of a given token ID to another address
* If the target address is a contract, it must implement {IARC721Receiver-onARC721Received},
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onARC721Received(address,address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
* Requires the _msgSender() to be the owner, approved, or operator
* @param from current owner of the token
* @param to address to receive the ownership of the given token ID
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes data to send along with a safe transfer check
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ARC721: transfer caller is not owner nor approved");
_safeTransferFrom(from, to, tokenId, _data);
}
/**
* @dev Safely transfers the ownership of a given token ID to another address
* If the target address is a contract, it must implement `onARC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onARC721Received(address,address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
* Requires the msg.sender to be the owner, approved, or operator
* @param from current owner of the token
* @param to address to receive the ownership of the given token ID
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes data to send along with a safe transfer check
*/
function _safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) internal {
_transferFrom(from, to, tokenId);
require(_checkOnARC721Received(from, to, tokenId, _data), "ARC721: transfer to non ARC721Receiver implementer");
}
/**
* @dev Returns whether the specified token exists.
* @param tokenId uint256 ID of the token to query the existence of
* @return bool whether the token exists
*/
function _exists(uint256 tokenId) internal view returns (bool) {
address owner = _tokenOwner[tokenId];
return owner != address(0);
}
/**
* @dev Returns whether the given spender can transfer a given token ID.
* @param spender address of the spender to query
* @param tokenId uint256 ID of the token to be transferred
* @return bool whether the msg.sender is approved for the given token ID,
* is an operator of the owner, or is the owner of the token
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
require(_exists(tokenId), "ARC721: operator query for nonexistent token");
address owner = ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
/**
* @dev Internal function to safely mint a new token.
* Reverts if the given token ID already exists.
* If the target address is a contract, it must implement `onARC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onARC721Received(address,address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
* @param to The address that will own the minted token
* @param tokenId uint256 ID of the token to be minted
*/
function _safeMint(address to, uint256 tokenId) internal {
_safeMint(to, tokenId, "");
}
/**
* @dev Internal function to safely mint a new token.
* Reverts if the given token ID already exists.
* If the target address is a contract, it must implement `onARC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onARC721Received(address,address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
* @param to The address that will own the minted token
* @param tokenId uint256 ID of the token to be minted
* @param _data bytes data to send along with a safe transfer check
*/
function _safeMint(address to, uint256 tokenId, bytes memory _data) internal {
_mint(to, tokenId);
require(_checkOnARC721Received(address(0), to, tokenId, _data), "ARC721: transfer to non ARC721Receiver implementer");
}
/**
* @dev Internal function to mint a new token.
* Reverts if the given token ID already exists.
* @param to The address that will own the minted token
* @param tokenId uint256 ID of the token to be minted
*/
function _mint(address to, uint256 tokenId) internal {
require(to != address(0), "ARC721: mint to the zero address");
require(!_exists(tokenId), "ARC721: token already minted");
_tokenOwner[tokenId] = to;
_ownedTokensCount[to].increment();
emit Transfer(address(0), to, tokenId);
}
/**
* @dev Internal function to burn a specific token.
* Reverts if the token does not exist.
* Deprecated, use {_burn} instead.
* @param owner owner of the token to burn
* @param tokenId uint256 ID of the token being burned
*/
function _burn(address owner, uint256 tokenId) internal {
require(ownerOf(tokenId) == owner, "ARC721: burn of token that is not own");
_clearApproval(tokenId);
_ownedTokensCount[owner].decrement();
_tokenOwner[tokenId] = address(0);
emit Transfer(owner, address(0), tokenId);
}
/**
* @dev Internal function to burn a specific token.
* Reverts if the token does not exist.
* @param tokenId uint256 ID of the token being burned
*/
function _burn(uint256 tokenId) internal {
_burn(ownerOf(tokenId), tokenId);
}
/**
* @dev Internal function to transfer ownership of a given token ID to another address.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
* @param from current owner of the token
* @param to address to receive the ownership of the given token ID
* @param tokenId uint256 ID of the token to be transferred
*/
function _transferFrom(address from, address to, uint256 tokenId) internal {
require(ownerOf(tokenId) == from, "ARC721: transfer of token that is not own");
require(to != address(0), "ARC721: transfer to the zero address");
_clearApproval(tokenId);
_ownedTokensCount[from].decrement();
_ownedTokensCount[to].increment();
_tokenOwner[tokenId] = to;
emit Transfer(from, to, tokenId);
}
/**
* @dev Internal function to invoke {IARC721Receiver-onARC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* This is an internal detail of the `ARC721` contract and its use is deprecated.
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnARC721Received(address from, address to, uint256 tokenId, bytes memory _data)
internal returns (bool)
{
if (!to.isContract) {
return true;
}
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = to.call(abi.encodeWithSelector(
IARC721Receiver(to).onARC721Received.selector,
_msgSender(),
from,
tokenId,
_data
));
if (!success) {
if (returndata.length > 0) {
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert("ARC721: transfer to non ARC721Receiver implementer");
}
} else {
bytes4 retval = abi.decode(returndata, (bytes4));
return (retval == _ARC721_RECEIVED);
}
}
/**
* @dev Private function to clear current approval of a given token ID.
* @param tokenId uint256 ID of the token to be transferred
*/
function _clearApproval(uint256 tokenId) private {
if (_tokenApprovals[tokenId] != address(0)) {
_tokenApprovals[tokenId] = address(0);
}
}
}
contract ARC721Metadata is Context, ARC165, ARC721, IARC721Metadata {
// Token name
string private _name;
// Token symbol
string private _symbol;
// Base URI
string private _baseURI;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
/*
* bytes4(keccak256('name()')) == 0x06fdde03
* bytes4(keccak256('symbol()')) == 0x95d89b41
* bytes4(keccak256('tokenURI(uint256)')) == 0xc87b56dd
*
* => 0x06fdde03 ^ 0x95d89b41 ^ 0xc87b56dd == 0x5b5e139f
*/
bytes4 private constant _INTERFACE_ID_ARC721_METADATA = 0x5b5e139f;
/**
* @dev Constructor function
*/
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
// register the supported interfaces to conform to ARC721 via ARC165
_registerInterface(_INTERFACE_ID_ARC721_METADATA);
}
/**
* @dev Gets the token name.
* @return string representing the token name
*/
function name() external view returns (string memory) {
return _name;
}
/**
* @dev Gets the token symbol.
* @return string representing the token symbol
*/
function symbol() external view returns (string memory) {
return _symbol;
}
/**
* @dev Returns the URI for a given token ID. May return an empty string.
*
* If the token's URI is non-empty and a base URI was set (via
* {_setBaseURI}), it will be added to the token ID's URI as a prefix.
*
* Reverts if the token ID does not exist.
*/
function tokenURI(uint256 tokenId) external view returns (string memory) {
require(_exists(tokenId), "ARC721Metadata: URI query for nonexistent token");
string memory _tokenURI = _tokenURIs[tokenId];
// Even if there is a base URI, it is only appended to non-empty token-specific URIs
if (bytes(_tokenURI).length == 0) {
return "";
} else {
// abi.encodePacked is being used to concatenate strings
return string(abi.encodePacked(_baseURI, _tokenURI));
}
}
/**
* @dev Internal function to set the token URI for a given token.
*
* Reverts if the token ID does not exist.
*
* TIP: if all token IDs share a prefix (e.g. if your URIs look like
* `http://api.myproject.com/token/`), use {_setBaseURI} to store
* it and save gas.
*/
function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal {
require(_exists(tokenId), "ARC721Metadata: URI set of nonexistent token");
_tokenURIs[tokenId] = _tokenURI;
}
/**
* @dev Internal function to set the base URI for all token IDs. It is
* automatically added as a prefix to the value returned in {tokenURI}.
*
* _Available since v2.5.0._
*/
function _setBaseURI(string memory baseURI) internal {
_baseURI = baseURI;
}
/**
* @dev Returns the base URI set via {_setBaseURI}. This will be
* automatically added as a preffix in {tokenURI} to each token's URI, when
* they are non-empty.
*
* _Available since v2.5.0._
*/
function baseURI() external view returns (string memory) {
return _baseURI;
}
/**
* @dev Internal function to burn a specific token.
* Reverts if the token does not exist.
* Deprecated, use _burn(uint256) instead.
* @param owner owner of the token to burn
* @param tokenId uint256 ID of the token being burned by the msg.sender
*/
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
// Clear metadata (if any)
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
}
}
/**
* @title AAC721MetadataMintable
* @dev ARC721 minting logic with metadata.
*/
contract ARC721MetadataMintable is ARC721, ARC721Metadata, MinterRole {
/**
* @dev Function to mint tokens.
* @param to The address that will receive the minted tokens.
* @param tokenId The token id to mint.
* @param tokenURI The token URI of the minted token.
* @return A boolean that indicates if the operation was successful.
*/
function mintWithTokenURI(address to, uint256 tokenId, string memory tokenURI) public onlyMinter returns (bool) {
_mint(to, tokenId);
_setTokenURI(tokenId, tokenURI);
return true;
}
}
/**
* @title ARC721Mintable
* @dev ARC721 minting logic.
*/
contract ARC721Mintable is ARC721, MinterRole {
/**
* @dev Function to mint tokens.
* @param to The address that will receive the minted token.
* @param tokenId The token id to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address to, uint256 tokenId) public onlyMinter returns (bool) {
_mint(to, tokenId);
return true;
}
/**
* @dev Function to safely mint tokens.
* @param to The address that will receive the minted token.
* @param tokenId The token id to mint.
* @return A boolean that indicates if the operation was successful.
*/
function safeMint(address to, uint256 tokenId) public onlyMinter returns (bool) {
_safeMint(to, tokenId);
return true;
}
/**
* @dev Function to safely mint tokens.
* @param to The address that will receive the minted token.
* @param tokenId The token id to mint.
* @param _data bytes data to send along with a safe transfer check.
* @return A boolean that indicates if the operation was successful.
*/
function safeMint(address to, uint256 tokenId, bytes memory _data) public onlyMinter returns (bool) {
_safeMint(to, tokenId, _data);
return true;
}
}
/**
* @title ARC-721 Non-Fungible Token Standard, optional enumeration extension
*/
contract IARC721Enumerable is IARC721 {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256 tokenId);
function tokenByIndex(uint256 index) public view returns (uint256);
}
/**
* @title ARC-721 Non-Fungible Token with optional enumeration extension logic
*/
contract ARC721Enumerable is Context, ARC165, ARC721, IARC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/*
* bytes4(keccak256('totalSupply()')) == 0x18160ddd
* bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) == 0x2f745c59
* bytes4(keccak256('tokenByIndex(uint256)')) == 0x4f6ccce7
*
* => 0x18160ddd ^ 0x2f745c59 ^ 0x4f6ccce7 == 0x780e9d63
*/
bytes4 private constant _INTERFACE_ID_ARC721_ENUMERABLE = 0x780e9d63;
/**
* @dev Constructor function.
*/
constructor () public {
// register the supported interface to conform to ARC721Enumerable via ARC165
_registerInterface(_INTERFACE_ID_ARC721_ENUMERABLE);
}
/**
* @dev Gets the token ID at a given index of the tokens list of the requested owner.
* @param owner address owning the tokens list to be accessed
* @param index uint256 representing the index to be accessed of the requested tokens list
* @return uint256 token ID at the given index of the tokens list owned by the requested address
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
require(index < balanceOf(owner), "ARC721Enumerable: owner index out of bounds");
return _ownedTokens[owner][index];
}
/**
* @dev Gets the total amount of tokens stored by the contract.
* @return uint256 representing the total amount of tokens
*/
function totalSupply() public view returns (uint256) {
return _allTokens.length;
}
/**
* @dev Gets the token ID at a given index of all the tokens in this contract
* Reverts if the index is greater or equal to the total number of tokens.
* @param index uint256 representing the index to be accessed of the tokens list
* @return uint256 token ID at the given index of the tokens list
*/
function tokenByIndex(uint256 index) public view returns (uint256) {
require(index < totalSupply(), "ARC721Enumerable: global index out of bounds");
return _allTokens[index];
}
/**
* @dev Internal function to transfer ownership of a given token ID to another address.
* As opposed to transferFrom, this imposes no restrictions on msg.sender.
* @param from current owner of the token
* @param to address to receive the ownership of the given token ID
* @param tokenId uint256 ID of the token to be transferred
*/
function _transferFrom(address from, address to, uint256 tokenId) internal {
super._transferFrom(from, to, tokenId);
_removeTokenFromOwnerEnumeration(from, tokenId);
_addTokenToOwnerEnumeration(to, tokenId);
}
/**
* @dev Internal function to mint a new token.
* Reverts if the given token ID already exists.
* @param to address the beneficiary that will own the minted token
* @param tokenId uint256 ID of the token to be minted
*/
function _mint(address to, uint256 tokenId) internal {
super._mint(to, tokenId);
_addTokenToOwnerEnumeration(to, tokenId);
_addTokenToAllTokensEnumeration(tokenId);
}
/**
* @dev Internal function to burn a specific token.
* Reverts if the token does not exist.
* Deprecated, use {ARC721-_burn} instead.
* @param owner owner of the token to burn
* @param tokenId uint256 ID of the token being burned
*/
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
_removeTokenFromOwnerEnumeration(owner, tokenId);
// Since tokenId will be deleted, we can clear its slot in _ownedTokensIndex to trigger a gas refund
_ownedTokensIndex[tokenId] = 0;
_removeTokenFromAllTokensEnumeration(tokenId);
}
/**
* @dev Gets the list of token IDs of the requested owner.
* @param owner address owning the tokens
* @return uint256[] List of token IDs owned by the requested address
*/
function _tokensOfOwner(address owner) internal view returns (uint256[] storage) {
return _ownedTokens[owner];
}
/**
* @dev Private function to add a token to this extension's ownership-tracking data structures.
* @param to address representing the new owner of the given token ID
* @param tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
_ownedTokensIndex[tokenId] = _ownedTokens[to].length;
_ownedTokens[to].push(tokenId);
}
/**
* @dev Private function to add a token to this extension's token tracking data structures.
* @param tokenId uint256 ID of the token to be added to the tokens list
*/
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
/**
* @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
* while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
* gas optimizations e.g. when performing a transfer operation (avoiding double writes).
* This has O(1) time complexity, but alters the order of the _ownedTokens array.
* @param from address representing the previous owner of the given token ID
* @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
// To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = _ownedTokens[from].length.sub(1);
uint256 tokenIndex = _ownedTokensIndex[tokenId];
// When the token to delete is the last token, the swap operation is unnecessary
if (tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
}
// This also deletes the contents at the last position of the array
_ownedTokens[from].length--;
// Note that _ownedTokensIndex[tokenId] hasn't been cleared: it still points to the old slot (now occupied by
// lastTokenId, or just over the end of the array if the token was the last one).
}
/**
* @dev Private function to remove a token from this extension's token tracking data structures.
* This has O(1) time complexity, but alters the order of the _allTokens array.
* @param tokenId uint256 ID of the token to be removed from the tokens list
*/
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
// To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = _allTokens.length.sub(1);
uint256 tokenIndex = _allTokensIndex[tokenId];
// When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
// rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
// an 'if' statement (like in _removeTokenFromOwnerEnumeration)
uint256 lastTokenId = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
// This also deletes the contents at the last position of the array
_allTokens.length--;
_allTokensIndex[tokenId] = 0;
}
}
contract ARC721Token is ARC721, AC721Enumerable, ARC721MetadataMintable {
constructor() public ARC721Metadata("ARC721Token", "YTN") {
}
}
```
# ACCOUNT MODEL
### Introduction
AIXChain uses account model. An account's identity is address. It needs private key signature to operate an account. An account has many attributes, like Aixc balance, tokens balance, bandwidth, etc. Aixc and tokens can be transfered from account to account and it costs bandwidth. An account can also issue a smart contract, apply to become a super representative candidate, vote, etc. All Aixc's activities are based on account.
### How to Create an Account
1. Use a wallet to generate the address and private key. To active the account, you need to transfer Aixc or transfer token to the new created account. [Generate an account](/http-api/api-list/accounts/createaccount)
2. Use an account already existed in AIXChain network to create an account
If you have enough staked BandWidth Points, creating an account only consume your staked BandWidth Points, otherwise, it burns 0.1 Aixc.
### Key-pair Generation
Aixc signature algorithm is ECDSA, curve used is SECP256K1. Private key is a random number, public key is a point in the elliptic curve. The process is: first generate a random number d to be the private key, then caculate P = d \* G as the public key, G is the elliptic curve base point.
### Address Format
Use the public key P as the input, by SHA3 get the result H. The length of the public key is 64 bytes, SHA3 uses Keccak256. Use the last 20 bytes of H, and add a byte of 0x41 in front of it, then the address come out. Do basecheck to address, here is the final address. All addresses start with 'A'.
basecheck process: first do sha256 caculation to address to get h1, then do sha256 to h1 to get h2, use the first 4 bytes as check to add it to the end of the address to get address||check, do base58 encode to address||check to get the final result.
character map: ALPHABET = "123456789ABCDEFGHJKLMNPQRSWUVTXYZabcdefghijkmnopqrswuvtxyz"
### Signature
#### Steps
1. Get the rawdata of the transaction, then transfer it to `byte[]`
2. Do sha256 calculation to the rawdata
3. Use the private key to sign the result gained from step 2
4. Add the signature back into the transaction
#### Algorithm
1. ECDSA, SECP256K
2. Example:
```
priKey:::8e812436a0e3323166e1f0e8ba79e19e217b2c4a53c970d4cca0cfb1078979df
pubKey::04a5bb3b28466f578e6e93fbfd5f75cee1ae86033aa4bbea690e3312c087181eb366f9a1d1d6a437a9bf9fc65ec853b9fd60fa322be3997c47144eb20da658b3d1
hash:::159817a085f113d099d3d93c051410e9bfe043cc5c20e43aa9a083bf73660145
r:::38b7dac5ee932ac1bf2bc62c05b792cd93c3b4af61dc02dbb4b93dacb758123f
s:::08bf123eabe77480787d664ca280dc1f20d9205725320658c39c6c143fd5642d
v:::0
```
Note: The size of the signature result is 65 bytes. r 32 bytes, s 32 bytes, v 1 bytes.
3. fullnode will verify the signature, it generates an address with the value of hash and r、s、v, then it compares with the address in the transaction.
#### Demo
public static Transaction sign(Transaction transaction, ECKey myKey) { Transaction.Builder transactionBuilderSigned = transaction.toBuilder(); byte\[] hash = sha256(transaction.getRawData().toByteArray()); List listContract = transaction.getRawData().getContractList();
```
for (int i = 0; i < listContract.size(); i++) {
ECDSASignature signature = myKey.sign(hash);
ByteString bsSign = ByteString.copyFrom(signature.toByteArray());
// Each contract may be signed with a different private key in the future.
transactionBuilderSigned.addSignature(bsSign);
}
```
}
# BUILD NODE
# How to setup a Super node to produce Blocks
# Recommended configuration & Environment
### Recommended configuration
CPU: 16 Cores, Memory: 32GB, Bandwidth: 100Mbps, SSD: 600GB
### Environment
Operating system: Linux
Libs and Tools: Docker, Docker-compose
# Example cloud services
You can choose configuration of these below options: