Home

Awesome

SimpleAssets

document version 17 March 2021

Scope:

  1. Introduction
  2. Contract actions
  3. Data Structures
  4. EXAMPLES: how to use Simple Assets in smart contracts
  5. AuthorReg
  6. ChangeLog

Introduction

A simple standard for digital assets on EOSIO blockchains: Non-Fungible Tokens (NFTs), Fungible Tokens (FTs), and Non-Transferable Tokens (NTTs).
by CryptoLions

中文翻译: https://github.com/CryptoLions/SimpleAssets/blob/master/README_ZH.md
한국어 번역: https://github.com/CryptoLions/SimpleAssets/blob/master/README_KR.md
Español: https://github.com/CryptoLions/SimpleAssets/blob/master/README_ES.md

WARNING The minimum dependency on eosio.cdt is now v1.6.3.

Use Simple Assets by making calls to the Simple Assets contract. It's like a Dapp for Dapps.

Jungle Testnet: simpleassets

EOS: simpleassets
WAX: simpleassets
MEETONE: smplassets.m
TELOS: simpleassets
PROTON: simpleassets
EUROPECHAIN: simpleassets

Simple Assets is a separate contract which other Dapps can call to manage their digital assets. This serves as an additional guarantee to users of the Dapp that the ownership of assets is managed by a reputable outside authority, and that once created, the Dapp can only manage the asset's mdata. All the ownership-related functionality exists outside the game.

Related: understanding ownership authority.

To post information about your NFTs to third-party marketplaces, use the authorreg action.

Alternatively, dapps can Deploy their own copy of Simple Assets and make modifications to have greater control of functionality, however this may compromise compatibility with wallets and other EOSIO infrastructure. Before deploying, Simple Assets should be modified to prevent anyone from making assets.

Resources

web: http://simpleassets.io
Git: https://github.com/CryptoLions/SimpleAssets
Telegram: https://t.me/simpleassets

Intro & Demos: https://medium.com/@cryptolions/introducing-simple-assets-b4e17caafaa4

(important for developers) A detailed description of each action parameter can be found here:
https://github.com/CryptoLions/SimpleAssets/blob/master/include/SimpleAssets.hpp

Events Receiver Example for authors: https://github.com/CryptoLions/SimpleAssets-EventReceiverExample

Author RAM Payer

NFT authors can enable Author RAM Payer for some or all of their NFTs, and pay for all the RAM associated with transfers so that users don't have to.

Read more about Author RAM Payer

Token Types

Non-Fungible Tokens (FTs)

NFTs are the most common type of digital assets. They are used to express unique tokens.

NFT Structure

Simple Asset NFTs are divided into mdata (data which the author can update at any time, regardless of ownership), and idata (data which is set upon the NFT's creation and can never be updated).

Both are stringified JSONs. For example: {\"key1\":\"some-string\", \"key2\":5}

Category is an optional field that lets you group your NFTs for convenience. Category names must be less than or equal to 12 characters (a-z, 1-5).

Offer/Claim versus Transfer - If you transfer an NFT, the sender pays for RAM. As an alternative, you can simply offer the NFT, and the user claiming will pay for their RAM. (Note: We've deployed an Author RAM Payer feature that allows NFT authors to pay for all the RAM of their NFTs.)

RAM usage

RAM usage for NFTs depends on how much data is stored in the idata and mdata fields. If they both empty, each NFT takes up 276 bytes.

Each symbol in idata and mdata is +1 byte.

Fungible Tokens (FTs)

Dapps which need Fungible tokens should decide between using the standard eosio.token contract, and the Simple Assets contract. Here are the differences:

In Simple Assets,

(Note: Fungible Tokens also have offer/claim functionality as an alternative to transfers. For FTs, the only time the sender would pay for RAM would be if the receiver never before held those FTs. It uses approximately 300 bytes to create the FT table.)

Non-Transferrable Tokens (NTTs)

The two most likely use cases for NTTs are

The reasons for using NTTs are:

More on NTTs: https://medium.com/@cryptolions/introducing-non-transferable-tokens-ntts-2f1a532bf170

Contract actions

A description of each parameter can be found here:
https://github.com/CryptoLions/SimpleAssets/blob/master/include/SimpleAssets.hpp

authorreg		( name author, string dappinfo, string fieldtypes, string priorityimg )
authorupdate		( name author, string dappinfo, string fieldtypes, string priorityimg )
setarampayer		( name author, name category, bool usearam ) 


 # -- For Non-Fungible Tokens (NFTs)---
 
 create			(author, category, owner, idata, mdata, requireсlaim)  
 update			(author, owner, assetid, mdata)  
 transfer		(from, to , [assetid1,..,assetidn], memo)  
 burn			(owner, [assetid1,..,assetidn], memo)  
 
 offer			(owner, newowner, [assetid1,..,assetidn], memo)  
 canceloffer		(owner, [assetid1,..,assetidn])  
 claim			(claimer, [assetid1,..,assetidn])  
  
 delegate		(owner, to, [assetid1,..,assetidn], period, redelegate, memo)  
 undelegate		(owner, [assetid1,..,assetidn])  
 delegatemore		(owner, assetid, period)  
 
 attach			(owner, assetidc, [assetid1,..,assetidn])
 detach			(owner, assetidc, [assetid1,..,assetidn])
 
 attachf		(owner, author, quantity, assetidc)
 detachf		(owner, author, quantity, assetidc)
 
 mdadd			(author, data)
 mdupdate		(id, author, data) 
 mdremove		(id)
 mdaddlog		(id, author, data)

 # -- For Fungible Tokens (FTs) ---
 
 createf		(author, maximum_supply, authorctrl, data)
 updatef		(author, sym, data)
 issuef			(to, author, quantity, memo)
 transferf		(from, to, author, quantity, memo)
 burnf			(from, author, quantity, memo)

 offerf			(owner, newowner, author, quantity, memo)
 cancelofferf		(owner, [ftofferid1,...,ftofferidn])
 claimf			(claimer, [ftofferid1,...,ftofferidn])

 openf			(owner, author, symbol, ram_payer)
 closef			(owner, author, symbol)
 
 # -- For Non-Transferable Tokens (NTTs) ---

 createntt		(author, category, owner, idata, mdata, requireсlaim)  
 updatentt		(author, owner, assetid, mdata)  
 burnntt		(owner, [assetid1,..,assetidn], memo)  
 claimntt		(claimer, [assetid1,..,assetidn])

Data Structures

Assets

sasset {  
	uint64_t	id; 		// asset id used for transfer and search;  
	name		owner;  	// asset owner (mutable - by owner!!!);  
	name		author;		// asset author (game contract, immutable);  
	name		category;	// asset category, chosen by author, immutable;  
	string		idata;		// immutable assets data. Can be stringified JSON (recommended) 
					// or just sha256 string;  
	string		mdata;		// mutable assets data, added on creation or asset update by author. Can be  
					// stringified JSON (recommended) or just sha256 string;  
					// using a format other than stringified JSON will not interfere with 
					// simple asset functionality, but will harm compatibility with third party
					// explorers attempting to diplay the asset

	sasset[]	container;	// other NFTs attached to this asset
	account[]	containerf;	// FTs attached to this asset
}

To help third party asset explorers, we recommend including the following fields in idata or mdata: name (text) img (url to image file)

Offers

offers {  
	uint64_t	assetid;	// asset id offered for claim ; 
	name		owner;		// asset owner;  
	name		offeredto;	// who can claim this asset ; 
	uint64_t	cdate;		// offer create date;  
}

Authors

authors {
        name    author;                 // assets author, who will be able to create and update assets;

        string  dappinfo;               // stringified JSON. Recommendations to include:
                                        // name - name of the application
                                        // company - name of the company
                                        // logo - url to image
                                        // url - url to the game's websites
                                        // info - short description of application
                                        // defaultfee - 100x the % fee you'd like to collect from marketplaces. (for 2%, 200)

        string  fieldtypes;             // data (json) schema to tell third-party markets how to display each NFT field.
                                        // key: state values, where key is the key from mdata or idata;
                                        // recommended values:

                                        // txt    | default type
                                        // url    | show as clickable URL
                                        // img    | link to img file
                                        // webgl  | link to webgl file
                                        // mp3    | link to mp3 file
                                        // video  | link to video file
                                        // hide   | do not show
                                        // imgb   | image as string in binary format
                                        // webglb | webgl binary
                                        // mp3b   | mp3 binary
                                        // videob | video binary
                                        //

        string  priorityimg;            // Specifies primary image field for categories of NFTs.
                                        //
                                        // This is used when you want your NFTs primary image to be something other
                                        // than a URL to an image field specified in the field img.  It also allows you to
                                        // create categories of NFTs with different primary image fields.
                                        //
                                        // data is a strigified json.
                                        // key: NFT categories.
                                        // value: a field from idata or mdata to be used as the primary image for
                                        // all NFTs of that category.

}

Delegates

delegates{  
	uint64_t	assetid;		// asset id offered for claim;  
	name		owner;			// asset owner;  
	name		delegatedto;		// who can claim this asset;  
	uint64_t	cdate;			// offer create date;   
	uint64_t	period;			// Time in seconds that the asset will be lent. Lender cannot undelegate until 
						// the period expires, however the receiver can transfer back at any time.
	bool 		redelegate;		// redelegate is allow more redelegate for to account or not.
	string		memo;			// memo from action parameters. Max 64 length.

}

Currency Stats (Fungible Token)

stat {  
	asset		supply;		// Tokens supply 
	asset		max_supply;	// Max token supply
	name		issuer;		// Fungible token author
	uint64_t	id;		// Unique ID for this token
	bool		authorctrl;	// if true(1) allow token author (and not just owner) to burn and transfer.
	string		data;		// stringified json. recommended keys to include: `img`, `name`
}

Account (Fungible Token)

accounts {  
	uint64_t	id;		// token id, from stat table
	name		author;		// token author
	asset		balance;	// token balance
}  

offerfs {
	uint64_t	id;		// id of the offer for claim (increments automatically) 
	name		author;		// ft author
	name		owner;		// ft owner
	asset		quantity;	// quantity
	name		offeredto;	// account which can claim the offer
	uint64_t	cdate;		// offer creation date
}

NTT

snttassets {  
	uint64_t	id; 		// NTT id used for claim or burn;  
	name		owner;  	// asset owner (mutable - by owner!!!);  
	name		author;		// asset author (game contract, immutable);  
	name		category;	// asset category, chosen by author, immutable;  
	string		idata;		// immutable assets data. Can be stringified JSON (recommended) 
					// or just sha256 string;  
	string		mdata;		// mutable assets data, added on creation or asset update by author. Can be  
					// stringified JSON (recommended) or just sha256 string;  
					// using a format other than stringified JSON will not interfere with 
					// simple asset functionality, but will harm compatibility with third party
					// explorers attempting to diplay the asset
}  

nttoffers {
	uint64_t	id;		// id of the offer for claim (increments automatically) 
	name		author;		// ntt author
	name		owner;		// ntt owner
	name		offeredto;	// account who can claim the offer
	uint64_t	cdate;		// offer creation date
}

More Data

moredata{
	uint64_t		id;	// id of the more data 
	name			author;	// author of the more data 
	string			data;	// more data. recommended format: strigified JSON
}

Author RAM Payer

sarampayer{
      uint64_t 			id;
      name    			author;
      name    			category;
      bool    			usearam;
      uint64_t  		from_id;

      auto primary_key() const {
        return id;
      }

      uint64_t by_author() const {
        return author.value;
      }
    };

EXAMPLES: how to use Simple Assets in smart contracts

Creating Asset and transfer to owner account ownerowner22:

name SIMPLEASSETSCONTRACT = "simpleassets"_n;

name author = get_self();
name category = "weapon"_n;
name owner = "ownerowner22"_n;
string idata = "{\"power\": 10, \"speed\": 2.2, \"name\": \"Magic Sword\" }";
string mdata = "{\"color\": \"bluegold\", \"level\": 3, \"stamina\": 5, \"img\": \"https://bit.ly/2MYh8EA\" }";

action createAsset = action(
	permission_level{author, "active"_n},
	SIMPLEASSETSCONTRACT,
	"create"_n,
	std::make_tuple( author, category, owner, idata, mdata,	0 )
);
createAsset.send();

Creating Asset with requireclaim option for ownerowner22:

name SIMPLEASSETSCONTRACT = "simpleassets"_n;

name author = get_self();
name category = "balls"_n;
name owner = "ownerowner22"_n;
string idata = "{\"radius\": 2, \"weigh\": 5, \"material\": \"rubber\", \"name\": \"Baseball\" }";
string mdata = "{\"color\": \"white\", \"decay\": 99, \"img\": \"https://i.imgur.com/QoTcosp.png\" }";


action createAsset = action(
	permission_level{author, "active"_n},
	SIMPLEASSETSCONTRACT,
	"create"_n,
	std::make_tuple( author, category, owner, idata, mdata, 1 )
);
createAsset.send();

Search asset and get assets info

  1. Please add in your hpp file info about assets structure
TABLE account {
	uint64_t	id;
	name		author;
	asset		balance;

	uint64_t primary_key()const { 
		return id;
	}
};
typedef eosio::multi_index< "accounts"_n, account > accounts;

TABLE sasset {
	uint64_t		id;
	name			owner;
	name			author;
	name			category;
	string			idata;
	string			mdata;
	std::vector<sasset>	container;
	std::vector<account>	containerf;

			
	auto primary_key() const {
		return id;
	}

	uint64_t by_author() const {
		return author.value;
	}
};

typedef eosio::multi_index< "sassets"_n, sasset, 		
		eosio::indexed_by< "author"_n, eosio::const_mem_fun<sasset, uint64_t, &sasset::by_author> >
> sassets;
  1. Searching and using info
name SIMPLEASSETSCONTRACT = "simpleassets"_n;
name author = get_self();
name owner = "lioninjungle"_n;

uint64_t assetid = 100000000000187

sassets assets(SIMPLEASSETSCONTRACT, owner.value);
auto idx = assets.find(assetid);

check(idx != assets.end(), "Asset not found or not yours");

check (idx->author == author, "Asset is not from this author");

auto idata = json::parse(idx->idata);  // for parsing json here is used nlohmann lib
auto mdata = json::parse(idx->mdata);  // https://github.com/nlohmann/json

check(mdata["cd"] < now(), "Not ready yet for usage");

Update Asset

name SIMPLEASSETSCONTRACT = "simpleassets"_n;

auto mdata = json::parse(idxp->mdata);
mdata["cd"] = now() + 84600;

name author = get_self();
name owner = "ownerowner22"_n;
uint64_t assetid = 100000000000187;

action saUpdate = action(
	permission_level{author, "active"_n},
	SIMPLEASSETSCONTRACT,
	"update"_n,
	std::make_tuple(author, owner, assetid, mdata.dump())
);
saUpdate.send();

Transfer one Asset

name SIMPLEASSETSCONTRACT = "simpleassets"_n;

name author = get_self();
name from = "lioninjungle"_n;
name to = "ohtigertiger"_n;

uint64_t assetid = 100000000000187;

std::vector<uint64_t> assetids;
assetids.push_back(assetid);

string memo = "Transfer one asset";

action saTransfer = action(
	permission_level{from, "active"_n},
	SIMPLEASSETSCONTRACT,
	"transfer"_n,
	std::make_tuple(from, to, assetids, memo)
);
saTransfer.send();

Transfer two Asset to same receiver with same memo

name SIMPLEASSETSCONTRACT = "simpleassets"_n;

name author = get_self();
name from = "lioninjungle"_n;
name to = "ohtigertiger"_n;

uint64_t assetid1 = 100000000000187;
uint64_t assetid2 = 100000000000188;

std::vector<uint64_t> assetids;
assetids.push_back(assetid1);
assetids.push_back(assetid2);

string memo = "Transfer two asset"

action saTransfer = action(
	permission_level{from, "active"_n},
	SIMPLEASSETSCONTRACT,
	"transfer"_n,
	std::make_tuple(from, to, assetids, memo)
);
saTransfer.send();

Burn Assets

name SIMPLEASSETSCONTRACT = "simpleassets"_n;

name owner = "lioninjungle"_n;
uint64_t assetid1 = 100000000000187;
uint64_t assetid2 = 100000000000188;

std::vector<uint64_t> assetids;
assetids.push_back(assetid1);
assetids.push_back(assetid2);

string memo = "Transfer two asset"

action saBurn = action(
	permission_level{owner, "active"_n},
	SIMPLEASSETSCONTRACT,
	"transfer"_n,
	std::make_tuple(owner, assetids, memo)
);
saBurn.send();

issuef (fungible) issue created token

name SIMPLEASSETSCONTRACT = "simpleassets"_n;

asset wood;
wood.amount = 100;
wood.symbol = symbol("WOOD", 0);

name author = get_self();
name to = "lioninjungle"_n;

std::string memo = "WOOD faucet";
action saRes1 = action(
	permission_level{author, "active"_n},
	SIMPLEASSETSCONTRACT,
	"issuef"_n,
	std::make_tuple(to, author, wood, memo)
);
saRes1.send();

transferf (fungible) by author if authorctrl is enabled

name SIMPLEASSETSCONTRACT = "simpleassets"_n;

asset wood;
wood.amount = 20;
wood.symbol = symbol("WOOD", 0);

name from = "lioninjungle"_n;
name to = get_self();
name author = get_self();

std::string memo = "best WOOD";
action saRes1 = action(
	permission_level{from, "active"_n},
	SIMPLEASSETSCONTRACT,
	"transferf"_n,
	std::make_tuple(from, to, author, wood, memo)
);
saRes1.send();

burnf (fungible) by author if authorctrl is enabled

name SIMPLEASSETSCONTRACT = "simpleassets"_n;

asset wood;
wood.amount = 20;
wood.symbol = symbol("WOOD", 0);

name author = get_self();
name from = "lioninjungle"_n;

std::string memo = "WOOD for oven";
action saRes1 = action(
	permission_level{author, "active"_n},
	SIMPLEASSETSCONTRACT,
	"burnf"_n,
	std::make_tuple(from, author, wood, memo)
);
saRes1.send();

AuthorReg

authorreg action

Authors can register in the authorreg table to communicate with third party asset explorers, wallets, and marketplaces.

ACTION authorreg( name author, string dappinfo, string fieldtypes, string priorityimg );

@param author is author's account who will create assets.

@param dappinfo is stringified JSON. Recommendations to include: name - name of the application
company - name of the company
logo - url to image
url - url to the game's websites
info - short description of application
defaultfee - 100x the % fee you'd like to collect from marketplaces. (for 2%, 200)

@param fieldtypes is stringified JSON with key:state values, where key is key from mdata or idata and state indicates recommended way of displaying the field. For the latest recommended values, please see https://github.com/CryptoLions/SimpleAssets/blob/master/include/SimpleAssets.hpp.

@param priorityimg is JSON which assosiates an NFT category with the field name from idata or mdata that specifies the main image field for that category of NFTs. This is probably a rare use case and can be left blank. If you wanted a category of NFTs to have a main image field other than img, you'd use "CATEGORY":"otherfieldname". Most likely use case is if you wanted webgls or some other format to be the main image.

Cleos examples of authorreg and authorupdate

authorreg

./cleos.sh.jungle push action simpleassets authorreg '["ilovekolobok", "{\"name\": \"Kolobok Breeding Game\", \"company\": \"CryptoLions\", \"info\": \"Breed your Kolobok\", \"logo\": \"https://imgs.cryptolions.io/logo_256.png\", \"url\": \"https://kolobok.io\", \"defaultfee\":200}", "{\"bdate\":\"timestamp\"},{\"cd\":\"timestamp\"},{\"img\":\"img\"},{\"st\":\"hide\"},{\"url\":\"url\"}", "{\"kolobok\":\"img\"},{\"*\":\"img\"}" ]' -p ilovekolobok

authorupdate

./cleos.sh.jungle push action simpleassets authorupdate '["ilovekolobok", "{\"name\": \"Kolobok Breeding Game\", \"company\": \"CryptoLions\", \"info\": \"Breed your Kolobok\", \"logo\": \"https://imgs.cryptolions.io/logo_256.png\", \"url\": \"https://kolobok.io\", \"defaultfee\":200}", "{\"bdate\":\"timestamp\"},{\"cd\":\"timestamp\"},{\"img\":\"img\"},{\"st\":\"hide\"},{\"url\":\"url\"}", "{\"kolobok\":\"img\"},{\"*\":\"img\"}" ]' -p ilovekolobok

Change Logs

Change Log v1.6.1

Change Log v1.6.0

Change Log v1.5.2

Change Log v1.5.1

Change Log v1.5.0

Change Log v1.4.1

Change Log v1.4.0

Change Log v1.3.0

Change Log v1.2.0

Change Log v1.1.3

Change Log v1.1.2

Change Log v1.1.1

Change Log v1.1.0

Change Log v1.0.1

Change Log v1.0.0

Change Log v0.4.2

Change Log v0.4.1

Change Log v0.4.0

Easily find fungible token information (fungible tokens have scope author):

More fungible token information:

Offer/claim fungible tokens

Containerizing assets

misc

Change Log v0.3.2

Change Log v0.3.1

Change Log v0.3.0

Change Log v0.2.0

Added Fungible Token tables and logic using eosio.token contract but with some changes

Change Log v0.1.1

Misc

Borrowing Assets

Batch Processing