One of HC Net’s most powerful features is the ability to trade any kind of asset, US dollars, Nigerian naira, bitcoins, special coupons, ICO tokens or just about anything you like.
This works in HC Net because an asset is really just a credit from a particular account. When you trade US dollars on the HC Net, you don’t actually trade US dollars—you trade US dollars credited from a particular account. Often, that account will be a bank, but if your neighbor had a banana plant, they might issue banana assets that you could trade with other people.
Every asset type (except HCX) is defined by two properties:
In the HC Net SDK, assets are represented with the Asset class:
Representing Assets
var astroDollar = new HCNetSdk.Asset(
'AstroDollar', 'GRTBKZPYOQYPDEFJKLKY9FNNRQMGFLVHKBVCGNSLRRGSMPGF78GFDCVK5');
KeyPair issuer = HCNetSdk.Keypair.fromAccountId(
"GRTBKZPYOQYPDEFJKLKY9FNNRQMGFLVHKBVCGNSLRRGSMPGF78GFDCVK5");
Asset astroDollar = Asset.createNonNativeAsset("AstroDollar", issuer);
// Wherever assets are used in Aurora, they use the following JSON structure:
{
"asset_code": "AstroDollar",
"asset_issuer":
"GRTBKZPYOQYPDEFJKLKY9FNNRQMGFLVHKBVCGNSLRRGSMPGF78GFDCVK5",
// `asset_type` is used to determine how asset data is stored.
// It can be `native` (HCX), `credit_alphanum4`, or `credit_alphanum12`.
"asset_type": "credit_alphanum12"
}
To issue a new type of asset, all you need to do is choose a code. It can be any combination of up to 12 letters or numbers, but you should use the appropriate ISO 4217 code (e.g. USD for US dollars) or ISIN for national currencies or securities. Once you’ve chosen a code, you can begin paying people using that asset code. You don’t need to do anything to declare your asset on the network.
However, other people can’t receive your asset until they’ve chosen to trust it. Because a HC Net asset is really a credit, you should trust that the issuer can redeem that credit if necessary later on. You might not want to trust your neighbor to issue banana assets if they don’t even have a banana plant, for example.
An account can create a trustline, or a declaration that it trusts a particular asset, using the change trust operation. A trustline can also be limited to a particular amount. If your banana-growing neighbor only has a few plants, you might not want to trust them for more than about 200 bananas. Note: each trustline increases an account’s minimum balance by 0.5 HCX (the base reserve). For more details, see the fees guide.
Once you’ve chosen an asset code and someone else has created a trustline for your asset, you’re free to start making payment operations to them using your asset. If someone you want to pay doesn’t trust your asset, you might also be able to use the Decentralized exchange.
Sending and receiving custom assets is very similar to sending and receiving HCX. Here’s a simple example:
Send Custom Assets
var HCNetSdk = require('HCNet-sdk');
HCNetSdk.Network.useTestNetwork();
var server = new HCNetSdk.Server('https://network.paybito.com/');
// Keys for accounts to issue and receive the new asset
var issuingKeys =HCNetSdk.Keypair
.fromSecret('SHRTYsGBA5YHTNKLK67UU25OE2B6P6F5T3U6MM63WBSBZATAQI5RVTTS');
var receivingKeys = HCNetSdk.Keypair
.fromSecret('SXDRTCRO8JRAI7UFAVLE5IMIZRD6N89WJUWKY4GFNUILOBEEJGSEKRSS');
// Create an object to represent the new asset
var astroDollar = new HCNetSdk.Asset('AstroDollar', issuingKeys.publicKey());
// First, the receiving account must trust the asset
server.loadAccount(receivingKeys.publicKey())
.then(function(receiver) {
var transaction = new HCNetSdk.TransactionBuilder(receiver)
// The `changeTrust` operation creates (or alters) a trustline
// The `limit` parameter below is optional
.addOperation(HCNetSdk.Operation.changeTrust({
asset: astroDollar,
limit: '1000'
}))
.build();
transaction.sign(receivingKeys);
return server.submitTransaction(transaction);
})
// Second, the issuing account actually sends a payment using the asset
.then(function() {
return server.loadAccount(issuingKeys.publicKey())
})
.then(function(issuer) {
var transaction = new HCNetSdk.TransactionBuilder(issuer)
.addOperation(HCNetSdk.Operation.payment({
destination: receivingKeys.publicKey(),
asset: astroDollar,
amount: '10'
}))
.build();
transaction.sign(issuingKeys);
return server.submitTransaction(transaction);
})
.catch(function(error) {
console.error('Error!', error);
});
Network.useTestNetwork();
Server server = new Server("https://network.paybito.com/");
// Keys for accounts to issue and receive the new asset
KeyPair issuingKeys = KeyPair
.fromSecretSeed("SHRTYsGBA5YHTNKLK67UU25OE2B6P6F5T3U6MM63WBSBZATAQI5RVTTS");
KeyPair receivingKeys = KeyPair
.fromSecretSeed("SXDRTCRO8JRAI7UFAVLE5IMIZRD6N89WJUWKY4GFNUILOBEEJGSEKRSS");
// Create an object to represent the new asset
Asset astroDollar = Asset.createNonNativeAsset("AstroDollar", issuingKeys);
// First, the receiving account must trust the asset
AccountResponse receiving = server.accounts().account(receivingKeys);
Transaction allowAstroDollars = new Transaction.Builder(receiving)
.addOperation(
// The `ChangeTrust` operation creates (or alters) a trustline
// The second parameter limits the amount the account can hold
new ChangeTrustOperation.Builder(astroDollar, "1000").build())
.build();
allowAstroDollars.sign(receivingKeys);
server.submitTransaction(allowAstroDollars);
// Second, the issuing account actually sends a payment using the asset
AccountResponse issuing = server.accounts().account(issuingKeys);
Transaction sendAstroDollars = new Transaction.Builder(issuing)
.addOperation(
new PaymentOperation.Builder(receivingKeys, astroDollar, "10").build())
.build();
sendAstroDollars.sign(issuingKeys);
server.submitTransaction(sendAstroDollars);
issuerSeed := "SHRTYsGBA5YHTNKLK67UU25OE2B6P6F5T3U6MM63WBSBZATAQI5RVTTS"
recipientSeed := "SXDRTCRO8JRAI7UFAVLE5IMIZRD6N89WJUWKY4GFNUILOBEEJGSEKRSS"
// Keys for accounts to issue and receive the new asset
issuer, err := keypair.Parse(issuerSeed)
if err !=nil { log.Fatal(err) }
recipient, err := keypair.Parse(recipientSeed)
if err != nil { log.Fatal(err) }
// Create an object to represent the new asset
astroDollar := build.CreditAsset("AstroDollar", issuer.Address())
// First, the receiving account must trust the asset
trustTx, err := build.Transaction(
build.SourceAccount{recipient.Address()}, build.AutoSequence{SequenceProvider:
build.TestNetwork,
build.Trust(astroDollar.Code, astroDollar.Issuer, build.Limit("100.25")),
)
if err != nil { log.Fatal(err) }
trustTxe, err := trustTx.Sign(recipientSeed)
if err != nil { log.Fatal(err) }
trustTxeB64, err := trustTxe.Base64()
if err != nil { log.Fatal(err) }
_, err = aurora.DefaultTestNetClient.SubmitTransaction(trustTxeB64)
if err != nil { log.Fatal(err) }
// Second, the issuing account actually sends a payment using the asset
paymentTx, err := build.Transaction(
build.SourceAccount{issuer.Address()},
build.TestNetwork,
build.AutoSequence{SequenceProvider:
aurora.DefaultTestNetClient},
build.Payment(
build.Destination{AddressOrSeed: recipient.Address()},
build.CreditAmount{"AstroDollar", issuer.Address(), "10"},
),
)
if err != nil { log.Fatal(err) }
paymentTxe, err := paymentTx.Sign(issuerSeed)
if err != nil { log.Fatal(err) }
paymentTxeB64, err := paymentTxe.Base64()
if err != nil { log.Fatal(err) }
_, err = aurora.DefaultTestNetClient.SubmitTransaction(paymentTxeB64)
if err != nil { log.Fatal(err) }
Another thing that is important when you issue an asset is to provide clear information about what your asset represents. This info can be discovered and displayed by clients so users know exactly what they are getting when they hold your asset. To do this you must do two simple things. First, add a section in your HCNet.toml file that contains the necessary meta fields:
Set Home Domain
var HCNetSdk = require('HCNet-sdk');
HCNetSdk.Network.useTestNetwork();
var server = new HCNetSdk.Server('https://network.paybito.com/');
// Keys for issuing account
var issuingKeys = HCNetSdk.Keypair
.fromSecret('SHRTYsGBA5YHTNKLK67UU25OE2B6P6F5T3U6MM63WBSBZATAQI5RVTTS');
server.loadAccount(issuingKeys.publicKey())
.then(function(issuer) {
var transaction =new HCNetSdk.TransactionBuilder(issuer)
.addOperation(HCNetSdk.Operation.setOptions({
homeDomain: 'yourdomain.com',
}))
.build();
transaction.sign(issuingKeys);
return server.submitTransaction(transaction);
})
.catch(function (error) {
console.error('Error!', error);
});
Network.useTestNetwork();
Server server = new Server("https://network.paybito.com/");
// Keys for issuing account
KeyPair issuingKeys = KeyPair
.fromSecretSeed("SHRTYsGBA5YHTNKLK67UU25OE2B6P6F5T3U6MM63WBSBZATAQI5RVTTS");
AccountResponse sourceAccount = server.accounts().account(issuingKeys);
Transaction setHomeDomain = new Transaction.Builder(sourceAccount)
.addOperation(new SetOptionsOperation.Builder()
.setHomeDomain("yourdomain.com").build()
.build();
setAuthorization.sign(issuingKeys);
server.submitTransaction(setHomeDomain);
Accounts have several flags related to issuing assets.
If you’d like to control who can be paid with your asset, or if your asset has some special purpose requiring sign-off from you, use the AUTHORIZATION REQUIRED flag, which requires that the issuing account also approves a trustline before the receiving account is allowed to be paid with the asset.
AUTHORIZATION REVOCABLE flag allows you to freeze assets you issued in case of theft or other special circumstances. This can be useful for national currencies, but is not always applicable to other kinds of assets.
For most cases, you should avoid setting AUTHORIZATION REVOCABLE on your asset. In the past, some issuers have used the AUTHORIZATION REVOCABLE flag in order to impose lock-up periods. However, this is a problematic mechanism because it does not provide the user any guarantees with regard to when or if the assets will be unlocked.
More importantly though, it requires a lot of effort to undo once it has been set. This is because if AUTHORIZATION REVOCABLE or AUTHORIZATION REQUIRED is disabled on an asset, it has no effect on existing user accounts. In order to be able to send your asset to existing accounts after these flags have been turned off, you will still need to run the Allow Trust operation for each existing user account. This requires creating a transaction with the following operations for every existing user account:
These transactions are necessary as you don’t want to effect accounts that have been created after you initially disabled authorization on your account - otherwise, they would also need to go through this process.
Asset Authorization
HCNetSdk.Network.useTestNetwork();
var transaction = new HCNetSdk.TransactionBuilder(issuingAccount)
.addOperation(HCNetSdk.Operation.setOptions({
setFlags: HCNetSdk.AuthRevocableFlag | HCNetSdk.AuthRequiredFlag
}))
.build();
transaction.sign(issuingKeys);
server.submitTransaction(transaction);
Network.useTestNetwork();
Server server = new Server("https://network.paybito.com/");
// Keys for issuing account
KeyPair issuingKeys = KeyPair
.fromSecretSeed("SHRTYsGBA5YHTNKLK67UU25OE2B6P6F5T3U6MM63WBSBZATAQI5RVTTS");
AccountResponse sourceAccount = server.accounts().account(issuingKeys);
Transaction setAuthorization = new Transaction.Builder(sourceAccount)
.addOperation(new SetOptionsOperation.Builder()
.setSetFlags(
AccountFlag.AUTH_REQUIRED_FLAG.getValue() |
AccountFlag.AUTH_REVOCABLE_FLAG.getValue())
.build())
.build();
setAuthorization.sign(issuingKeys);
server.submitTransaction(setAuthorization);
Once you begin issuing your own assets, there are a few smart practices you can follow for better security and easier management.
All operations on the HC Net (create account, set options, payment, etc.) should be submitted as part of a single HC Net transaction. Transactions in HC Net are atomic, which means that all operations succeed, or they all fail together. This ensures that token distribution will not get stuck in a middle state, e.g. where an account has been created but has not been funded.
In the simplest situations, you can issue assets from your everyday HC Net account. However, if you operate a financial institution or a business, you should keep a separate account specifically for issuing assets. Why?
Because every transaction comes with a small fee, you might want to check to ensure an account has a trustline and can receive your asset before sending a payment. If an account has a trustline, it will be listed in the accounts balances (even if the balance is 0).
Checking Trust
var astroDollarCode = 'AstroDollar';
varastroDollarIssuer =
'GRTBKZPYOQYPDEFJKLKY9FNNRQMGFLVHKBVCGNSLRRGSMPGF78GFDCVK5';
var accountId = 'GRSX5RFPE6GCKMY3US5U8B6UZLKIGSPIUKSLRB6Q723BM2OARMDUYEIO';
server.loadAccount(accountId).then(function(account) {
var trusted = account.balances.some(function (balance) {
return balance.asset_code === astroDollarCode &&
balance.asset_issuer === astroDollarIssuer;
});
console.log(trusted ? 'Trusted :)' : 'Not trusted :(');
});
Asset astroDollar = Asset.createNonNativeAsset(
"AstroDollar",
KeyPair.fromAccountId(
"GRTBKZPYOQYPDEFJKLKY9FNNRQMGFLVHKBVCGNSLRRGSMPGF78GFDCVK5"));
// Load the account you want to check
KeyPair keysToCheck = KeyPair.fromAccountId(
"GRSX5RFPE6GCKMY3US5U8B6UZLKIGSPIUKSLRB6Q723BM2OARMDUYEIO");
AccountResponse accountToCheck = server.accounts().account(keysToCheck);
// See if any balances are for the asset code and issuer we're looking for
boolean trusted = false;
for (AccountResponse.Balance balance : accountToCheck.getBalances()) {
if (balance.getAsset().equals(astroDollar)) {
trusted = true;
break;
}
}
System.out.println(trusted ? "Trusted :)" : "Not trusted :(");
When someone tries to buy or sell your asset on the decentralized exchange there needs to be a counterparty with whom they can trade. In other words, there needs to be enough liquidity for your asset.
This can be solved by using a liquidity provider. This can be someone who is contracted to provide this service for a fee, or as the asset issuer, you can provide this liquidity by using a market making bot.
Now that you have a basic understanding of custom assets, get familiar with the technical details in our assets concept document.
