Fungible Token

Creating Instances

Creating fungible token requires approval from authorities.

FungibleToken . create ( properties, signerOrProvider )   => Promise<FungibleToken>

Creates a new instance reference from signerOrProvider, then sends fungible token creation transaction to the network and returns a Promise that resolves to a FungibleToken instance.

The valid fungible token properties are:

  • name: string name for the token
  • symbol: string symbol for the token
  • decimals: ref:*BigNumber* <bignumber> the number of decimals for balance
  • fixedSupply: bool the supply mechanisms type (true: fixed, false: dynamic)
  • maxSupply: ref:*BigNumber* <bignumber> the maximum supply, set to 0 for unlimited supply (only applicable to dynamic supply type)
  • fee: int application fee
  • owner: the owner of the token (default to wallet creator)
  • metadata: string remarks (optional)

Note

name and symbol should be unique.

create fungible token
let wallet = new mxw.Wallet(0x00000000000000000000000000000000000000000000000070726f7669646572);
let fungibleTokenProperties = {
    name: "MY " + "symbol",
    symbol: "symbol",
    decimals: 18,
    fixedSupply: true,
    maxSupply: bigNumberify("100000000000000000000000000"),
    fee: {
        to: "address",
        value: bigNumberify("1")
    },
    metadata: ["Wallet is able to manage their own metadata"]
};

mxw.token.FungibleToken.create(FungibleTokenProperties, wallet).then((token) => {
    console.log(JSON.stringify(token))
});
FungibleToken . fromSymbol ( symbol, signerOrProvider )   => Promise<FungibleToken>
Queries fungible token by symbol from network and returns a Promise that resolves to a FungibleToken instance.
check token state
    mxw.token.FungibleToken.fromSymbol("symbol", wallet).then((token)=>{
        console.log(JSON.stringify(token));
    });

Prototype

prototype . state   => TokenState

(Read-only)
The valid token states are:
  • type — token type (fungible or non-fungible)
  • name — unique token name
  • symbol — unique token symbol
  • decimals — number of decimals for balance
  • fixedSupply — supply mechanism types (true: fixed, false: dynamic)
  • totalSupply — total current supply for the token
  • maxSupply — maximum supply for the token
  • approved — approval status
  • frozen — frozen status
  • owner — token owner’s address
  • metadata — optional
  • burnable — whether the token balance can be burned, this will be always true for token with dynamic supply
prototype . getBalance ( )   => Promise<BigNumber>
Returns a Promise that resolves to the fungible token balance (as a BigNumber) of the wallet. Be aware of the number of decimals applied to the token. The balance can be converted to a human-readable format by formatUnits, versa parseUnits.
prototype . transfer ( AddressOrName, value )   => Promise<TransactionReceipt>

Sends the transfer fungible token transaction to the network and returns a Promise that resolves to a Transaction Receipt.

The AddressOrName can be set to recipient’s alias or wallet address. The value is the number of fungible token (as a BigNumber) that is being transferred to recipient. Be aware of the number of decimals applied to the token.

prototype . mint ( AddressOrName, value )   => Promise<TransactionReceipt>

Sends the mint fungible token transaction to the network and returns a Promise that resolves to a Transaction Receipt.

The AddressOrName can be set to recipient’s alias or wallet address. The value is the number of fungible token (as a BigNumber) that is being minedted to recipient. Be aware of the number of decimals applied to the token.

Note

Only fungible token owner is allowed to sign mint transaction.

prototype . burn ( value )   => Promise<TransactionReceipt>

Sends the burn fungible token transaction to the network and returns a Promise that resolves to a Transaction Receipt.

The value is the number of fungible token (as a BigNumber) to be burned. Be aware of the number of decimals applied to the token.

burn a fungible token
let ftInstance = new NonFungibleTokenItem(symbol, itemID, wallet);
    ftInstance.burn().then((receipt) => {
            console.log(receipt);
    });
prototype . freeze ( AddressOrName )   => Promise<TransactionReceipt>

Sends the freeze fungible token transaction to the network and returns a Promise that resolves to a Transaction Receipt.

The AddressOrName can be set to target token holder’s alias or wallet address of which is to be frozen.

Note

Only fungible token middleware is allowed to sign freeze transaction.

freeze token
    let provider = new mxw.Wallet(0x00000000000000000000000000000000000000000000000070726f7669646572);
    let issuer = new mxw.Wallet(0x0000000000000000000000000000000000000000000000000000697373756572);
    let middleware = new mxw.Wallet(0x000000000000000000000000000000000000000000006d6964646c6577617265);

    mxw.token.FungibleToken.freezeFungibleToken("symbol","itemID", provider).then((transaction) => {
        mxw.token.FungibleToken.signFungibleTokenStatusTransaction(transaction, issuer).then((transaction) => {
            mxw.token.FungibleToken.sendFungibleTokenStatusTransaction(transaction, middleware).then((receipt) => {
                console.log(JSON.stringify(receipt));
            });
        });
    });
prototype . unfreeze ( AddressOrName )   => Promise<TransactionReceipt>

Sends the unfreeze fungible token transaction to the network and returns a Promise that resolves to a Transaction Receipt.

The AddressOrName can be set to target token holder’s alias or wallet address of which is to be unfrozen.

Note

Only fungible token middleware is allowed to sign unfreeze transaction.

unfreeze token
    let provider = new mxw.Wallet(0x00000000000000000000000000000000000000000000000070726f7669646572);
    let issuer = new mxw.Wallet(0x0000000000000000000000000000000000000000000000000000697373756572);
    let middleware = new mxw.Wallet(0x000000000000000000000000000000000000000000006d6964646c6577617265);

    mxw.token.FungibleToken.unfreezeFungibleToken("symbol","itemID", provider).then((transaction) => {
        mxw.token.FungibleToken.signFungibleTokenStatusTransaction(transaction, issuer).then((transaction) => {
            mxw.token.FungibleToken.sendFungibleTokenStatusTransaction(transaction, middleware).then((receipt) => {
                console.log(JSON.stringify(receipt));
            });
        });
    });