Mission 4 — Interact with Tokens

Until now, most of our examples have used $A, Vaulta's officially designated network token. But the Vaulta blockchain can contain many different tokens, each defined and managed by a smart contract.

In this mission, you will use Blocksfinity to inspect three real tokens on Vaulta, learn what contract, symbol, supply, maximum supply, issuer, and balances mean, and then perform an $A → $EOS and $EOS → $A swap.

The most important lesson is that a token is more than its ticker symbol.

A token is defined by a smart contract

On Vaulta, fungible tokens are implemented through smart contracts.

A token is identified by the combination of its contract and its symbol.

For example:

• $A — symbol A, smart contract core.vaulta

• $EOS — symbol EOS, smart contract eosio.token

• $V — symbol V, smart contract token.rms

Blocksfinity exposes this distinction directly in its Tokens section. You can search tokens by symbol or contract, and each token has its own page showing the contract and token information.

Open Blocksfinity Tokens

Key idea: A ticker symbol alone does not uniquely identify a token. The contract + symbol tells you which on-chain asset you are actually dealing with.

For example:

core.vaulta::A

identifies Vaulta's $A token.

A different smart contract could theoretically create another token also displaying the symbol A:

another.token::A

Those would be different tokens, even though their ticker symbols look identical.

This becomes especially important when interacting with unfamiliar tokens, smart contracts, or decentralized exchanges.

How $A and $EOS coexist on Vaulta

Vaulta introduced $A as the network's new token after the rebrand from EOS to Vaulta and officially describes it as the network's native resource and governance token. However, $EOS was not deleted from the blockchain. The existing eosio.token::EOS token continues to exist on-chain. Vaulta's own transition documentation states that unswapped $EOS remains on-chain and that the existing network, accounts, contracts, infrastructure, and blockchain history continued rather than moving to a new blockchain.

The mental model for both tokens is:

Vaulta blockchain
│
├── eosio.token::EOS
│      Existing $EOS token (Still exists on-chain)
│
├── core.vaulta::A
│      $A token (the newly introduced token)
│
└── core.vaulta
       ├── manages $A
       ├── provides the $A ↔ $EOS conversion
       └── provides wrappers (for system smart contract actions that continue to expect $EOS)

The core.vaulta contract has three closely related roles:

1. it implements the $A token;

2. it provides the special 1:1 conversion between $A and $EOS;

3. it provides a system wrapper that allows users to interact with existing Vaulta system functions using $A. GitHub

Why do we still see $EOS in system functions?

Vaulta did not rewrite every existing system smart contract around an entirely new token architecture.

Some underlying system operations still work with $EOS. The core.vaulta wrapper can accept $A, convert the required amount to $EOS internally, and then invoke the existing system action, which still expects $EOS.

The current core.vaulta documentation specifically describes this behavior for actions including:

• buyram

• buyrambytes

• powerup

• delegatebw

• deposit

• bidname

• donatetorex

This explains why you can see both $A and $EOS when examining Vaulta's system contracts.

Key idea: $A and $EOS are two distinct tokens on the same Vaulta blockchain. $A is Vaulta's officially designated network token, but $EOS still exists and remains relevant to parts of the underlying system-contract architecture.

The transition therefore did not mean:

$EOS disappeared
        ↓
$A took its place everywhere

A more accurate model is:

Existing Vaulta / EOS system
        +
new core.vaulta contract
        ↓
$A token
$A ↔ $EOS conversion
$A-aware wrappers around existing system actions

What does a token contract actually do?

A token contract contains the rules and blockchain state that make a token work.

Sidenote: Antelope.io is the underlying software framework and development stack that powers the Vaulta blockchain.

A common Antelope-style token smart contract provides actions for:

• creating a token;

• issuing tokens;

• maintaining account balances;

• transferring tokens;

• retiring tokens;

• opening and closing balance rows.

The Antelope reference token contract includes actions such as create, issue, transfer, retire, open, and close. Different token contracts can implement different rules, so this should be understood as a common model rather than a requirement for every token. GitHub

Create

Creating a token establishes important properties such as:

• its symbol;

• its decimal precision;

• its maximum supply;

• its issuer.

The maximum supply is the upper limit established by the token contract.

Creating a token does not necessarily mean all of those tokens have already been issued.

Issue

The issuer can issue tokens according to the token contract's rules, up to its permitted maximum supply.

This gives us an important distinction:

Maximum supply = the maximum amount that the contract permits.

Supply = the amount that the contract currently reports as issued.

Blocksfinity also makes this distinction on its token pages. It explains that its Supply value represents what the contract has issued on-chain. This can differ from another service's circulating supply, because circulating-supply calculations may exclude treasury, reserve, or other balances. Blocksfinity

Key idea: On-chain supply and circulating supply do not necessarily mean the same thing.

Balances

Token balances are stored by their respective smart contracts.

Your Vaulta account therefore does not have one universal token balance.

The same account can have balances belonging to many different token contracts:

Your Vaulta account
│
├── core.vaulta → $A
├── eosio.token → $EOS
├── token.rms   → $V
└── other token contracts...

The Vaulta account is the same.

The smart contracts maintaining those token balances are different.

Transfer

A transfer action tells a token contract to move a specified amount from one account's balance to another account's balance according to that smart contract's rules.

In the standard Antelope token implementation, the sender's balance is debited and the receiver's balance is credited. GitHub

You already performed this kind of action when you completed your first token-transfer mission.

Inspect three real Vaulta tokens

Open the Tokens section in Blocksfinity.

Open Blocksfinity Tokens

Blocksfinity lets you search by token symbol or contract and open individual token pages.

For each token, Blocksfinity can show information such as:

• supply;

• maximum supply;

• issuer;

• contract;

• decimal precision;

• accounts holding the token.

Blocksfinity also makes an important warning clear:

Listing a token is not an endorsement.

A token appearing in an explorer proves that the token exists according to the blockchain data. It does not prove that the token is valuable, trustworthy, liquid, safe, or legitimate.

1. Inspect $A

Open the $A token page in Blocksfinity.

Open $A — core.vaulta::A

Blocksfinity identifies the token as:

Symbol:   A
Contract: core.vaulta

Look for:

• Supply

• Max supply

• Issuer

• Contract

• Decimals

• Top 100 accounts

Blocksfinity identifies $A as a token on the core.vaulta smart contract.

Notice that the important identifier is not simply:

A

but:

core.vaulta::A

That combination tells you exactly which token you are examining.

2. Inspect $EOS

Now open $EOS.

Open $EOS — eosio.token::EOS

Look for the same information:

• Supply

• Max supply

• Issuer

• Contract

• Decimals

• Top 100 accounts

This time the identity is:

Symbol:   EOS
Contract: eosio.token

Blocksfinity confirms that $EOS remains an existing token on the eosio.token smart contract.

This is an important observation.

$A and $EOS are not simply two names displayed for the same token balance.

They are two different token identities:

core.vaulta::A
eosio.token::EOS

Their special relationship comes from the core.vaulta conversion mechanism.

3. Inspect $V

Now inspect $V.

Open $V — token.rms::V

Look again for:

• Supply

• Max supply

• Issuer

• Contract

• Decimals

• Top 100 accounts

This time you should see:

Symbol:   V
Contract: token.rms

Blocksfinity identifies $V as a token managed by the token.rms smart contract.

You have now inspected three separate token identities:

core.vaulta::A
eosio.token::EOS
token.rms::V

Checkpoint: $A, $EOS, and $V all exist on Vaulta, but they are not three balances maintained by one universal token database. Their balances and rules belong to their respective smart contracts.

Can anyone create a token?

In practical terms, developers can deploy their own token contracts and create tokens on Vaulta. Tools such as Blocksfinity Explorer also simplify this process by providing a user-friendly way to deploy and configure a token without having to code a smart contract and build the entire deployment flow manually.

There is an important technical distinction, however.

You cannot simply tell somebody else's token contract to create arbitrary tokens for you unless that contract's rules authorize you to do so.

A developer who wants independent control over a token can deploy a token smart contract to an account they control and create tokens according to that contract's rules.

But creating a token does not automatically create economic value.

A developer could create:

1,000,000,000 MYTOKEN

That alone does not mean:

• anyone wants it;

• anyone will buy it;

• a market exists for it;

• it can be exchanged for $A;

• useful liquidity exists;

• the token is trustworthy;

• the smart contract which manages the token is secure;

• Vaulta or Blocksfinity endorses it.

Important: The fact that a token exists on-chain is not an endorsement of the token, issuer, value, or security.

Blocksfinity explicitly states that listing a token in its Tokens section is not an endorsement.

This is another reason why the token's smart contract + symbol matters more than its name or logo alone.

How does a token become tradeable?

Creating a token and creating a market for that token are two different things.

One way a token can become tradeable is through a decentralized exchange (DEX).

A DEX uses smart contracts or other on-chain mechanisms to allow users to exchange different tokens.

For example:

$A
 ↓
DEX liquidity pool / trading mechanism smart contract logic
 ↓
$V

In a liquidity-pool-based market, users or projects provide assets to the pool. Traders can then exchange one token for another according to the market mechanism.

This introduces concepts such as:

• available liquidity;

• market price;

• trading fees;

• slippage;

• trading volume;

• exact token identities;

• the possibility of very little liquidity.

Creating a token therefore does not automatically create a useful market for it.

A token can exist perfectly well on Vaulta while having no meaningful market or exchange price.

Blocksfinity reflects this distinction in its Tokens section. Prices are displayed only where its market-data source considers the market sufficiently reliable; thinly traded pools may have no displayed price.

$A and $EOS are a special case

$A and $EOS should not be used as the example for how an ordinary DEX trade works.

The core.vaulta contract provides a special 1:1 conversion mechanism between the two tokens.

At the contract level, the model is:

$A
 ↓
core.vaulta (exchanges the tokens 1:1 without any fees)
 ↓
$EOS

and:

$EOS
 ↓
core.vaulta (exchanges the tokens 1:1 without any fees)
 ↓
$A

The core.vaulta contract documentation describes the token swap as a 1:1 swap. A user sends one token to the contract, and the contract returns the equivalent amount of the other token. It also states that the contract swap has no swap fee and no slippage. GitHub

So conceptually:

1 $A ↔ 1 $EOS

This is fundamentally different from:

$A
 ↓
DEX market / liquidity pool (charges fees, has slippage depending on how much liquidity is in the pool of a specific trading pair)
 ↓
$V

Why is this different from a DEX?

In the $A/$EOS system conversion, the conversion relationship is defined by the Vaulta contract mechanism.

There is no ordinary market deciding that:

1 $A = 0.83 $EOS

today and:

1 $A = 1.14 $EOS

tomorrow.

The contract conversion is designed around:

1 $A = 1 $EOS

Blocksfinity also reflects this relationship in its Tokens section by pricing $A 1:1 with $EOS because of the on-chain swap mechanism.

A normal DEX is different.

A DEX exchange rate may depend on:

• buyers and sellers;

• liquidity;

• pool balances;

• market demand;

• trading fees;

• slippage.

Key idea: Two interfaces can both use the word Swap, while the blockchain mechanisms underneath them can be completely different.

Mission: Swap a small amount of $A to $EOS

For this exercise, use only a small test amount.

Step 1 — Check the direction

Open the Blocksfinity Swap function and confirm that the direction is:

$A → $EOS

The two token identities involved are:

From: core.vaulta::A
To:   eosio.token::EOS

Step 2 — Enter a small amount

For example:

0.0100 $A

Before proceeding, check your current $A and $EOS balances. You should have at least 0.01 $A in your balance.

Step 3 — Check what you will receive

The conversion is 1:1:

0.0100 $A
      ↓
0.0100 $EOS

This is the moment to connect the interface with what you have just learned.

Blocksfinity prepares the interaction.

The actual tokens and balances exist on the Vaulta blockchain, and the system smart contract core.vaulta processes the conversion on-chain.

Step 4 — Select Swap

Select Swap.

Before approving the resulting transaction, carefully inspect the transaction presented by your signing tool.

Checkpoint: Confirm the account, token, amount, conversion direction, contract, and action you are authorizing. Do not approve a signing request simply because it appeared after you clicked a button.

In Blocksfinity Authenticator you should see something similar to this:

To: core.vaulta

Quantity: 0.0100 A

Only sign if the transaction matches what you intended to do.

Step 5 — Verify the result

After the transaction has been confirmed, inspect your balances again.

You should now be able to explain why:

$A balance   ↓
$EOS balance ↑

Then inspect the resulting transaction in your transaction history.

The important point is that Blocksfinity did not merely change two numbers on a webpage.

An on-chain smart contract processed the conversion, and Blocksfinity now reads and displays the resulting blockchain state.

Mission: Swap a small amount of $EOS back to $A

Now perform the opposite conversion with another small test amount.

Step 1 — Reverse the direction

Confirm:

$EOS → $A

The identities are now:

From: eosio.token::EOS
To:   core.vaulta::A

Step 2 — Enter a small amount

For example:

0.0100 $EOS

Check your current balances before proceeding.

Step 3 — Verify the 1:1 conversion

You should expect:

0.0100 $EOS
        ↓
0.0100 $A

Again, this is not normal DEX price discovery.

You are using the special relationship implemented by core.vaulta.

Step 4 — Review and sign

Before signing, verify:

• your account;

• the amount;

• the $EOS token;

• the destination/action involved;

Approve only if the transaction details matches what you intended.

Step 5 — Verify the result

After confirmation:

$EOS balance ↓
$A balance   ↑

The two transactions together demonstrate something important:

$A and $EOS are separate tokens
             +
core.vaulta connects them through a special 1:1 mechanism

What about swapping $V?

$V is different.

There is no reason to assume:

1 $V = 1 $A

and simply owning $V does not create a system conversion mechanism like the one between $A and $EOS.

To exchange a specific token with $V or exchange $V for another token, you would need a market or another conversion mechanism that supports the exact tokens involved.

Conceptually:

$A
 ↓
DEX / trading pair / liquidity
 ↓
$V

The market would have to identify the exact assets:

token.rms::V
core.vaulta::A

—not merely the labels $V and $A.

If this were a normal market, the exchange rate might also change according to available liquidity and market activity.

For example:

10 $V → 0.8 $A

at one moment does not guarantee that the same exchange rate will exist later.

That is very different from the special $A/$EOS conversion mechanism.

What just happened?

In this mission you did more than press Swap:

1. You inspected real token contracts using Blocksfinity.

2. You learned that a token's identity includes its contract + symbol.

3. You compared core.vaulta::A, eosio.token::EOS, and token.rms::V.

4. You inspected supply, maximum supply, issuer, decimals, contract, and token holders.

5. You learned that $A and $EOS are two different tokens that coexist on the same blockchain.

6. You learned that core.vaulta provides the $A token, the special $A/$EOS conversion, and wrappers around existing system functionality.

7. You saw why $EOS can still appear inside Vaulta's underlying system architecture.

8. You performed an $A → $EOS 1:1 conversion.

9. You performed an $EOS → $A 1:1 conversion.

10. You authorized on-chain transactions rather than merely changing balances inside Blocksfinity.

11. You learned why the $A/$EOS conversion is fundamentally different from an ordinary DEX trade.

What you should remember

• $A and $EOS are distinct on-chain tokens.

• $A uses the core.vaulta smart contract.

• $EOS uses the eosio.token smart contract.

• Vaulta officially designates $A as its network token, but $EOS still exists on-chain and remains relevant to parts of the existing system architecture.

• core.vaulta provides the $A token, the $A/$EOS conversion mechanism, and system wrappers.

• Some system-wrapper operations can accept $A and internally convert what is required to $EOS before invoking an existing system action.

• A token is identified by contract + symbol, not by its symbol alone.

• Blocksfinity lets you inspect token contracts, supply, maximum supply, issuer, decimals, and major holders.

• Supply is not automatically the same thing as circulating supply or market value.

• Creating a token does not create demand, liquidity, legitimacy, or value.

• A Blocksfinity token listing is not an endorsement.

• The $A/$EOS system conversion is a special 1:1 contract mechanism, not an ordinary market-priced DEX trade.

• A normal DEX can involve changing prices, liquidity, fees, and slippage.

• Before interacting with an unfamiliar token, verify its contract, not merely its ticker, name, or logo.

Quick Quiz

1. What is the safest way to identify a token on Vaulta?

• A. Its logo

• B. Its ticker symbol alone

• C. Its smart contract together with its symbol

• D. Its current market price

2. What is the relationship between $A and $EOS?

• A. $EOS was deleted when $A was created.

• B. They are the exact same token balance with two different names.

• C. They are separate on-chain tokens connected by Vaulta's core.vaulta conversion mechanism.

• D. $EOS now exists on a different blockchain.

3. Why might you still see $EOS when examining Vaulta system functions?

• A. Vaulta secretly uses another blockchain.

• B. Some existing system actions still use $EOS internally, while core.vaulta can provide $A-aware wrapper functionality around them.

• C. Blocksfinity incorrectly displays every $A transaction as $EOS.

• D. $A cannot interact with system contracts.

4. What is the difference between supply and maximum supply?

• A. Supply is the amount issued according to the contract; maximum supply is the configured upper limit.

• B. Supply is the market value; maximum supply is the issuer's wallet balance.

• C. They must always be identical.

• D. Maximum supply tells you how much liquidity exists on a DEX.

5. Why is the $A ↔ $EOS conversion different from an ordinary DEX swap?

• A. $EOS exists on another blockchain.

• B. It uses Vaulta's special 1:1 contract conversion rather than ordinary market-price discovery.

• C. DEXs cannot use smart contracts.

• D. $A and $EOS cannot both be held by the same Vaulta account.

6. Two tokens both display the symbol ABC, but one comes from first.token and the other from second.token. What should you conclude?

• A. They must be the same token because their symbols match.

• B. Vaulta automatically combines their balances.

• C. They are different token identities unless some separate mechanism establishes a relationship between them.

• D. The token with the larger supply must be the real one.

Answer footnote: Q1:3; Q2:3; Q3:2; Q4:1; Q5:2; Q6:3.