Module com.hedera.hashgraph.sdk
Package com.hedera.hashgraph.sdk

Class TokenCreateTransaction

java.lang.Object
com.hedera.hashgraph.sdk.Executable<TokenCreateTransaction,Transaction,TransactionResponse,TransactionResponse>
com.hedera.hashgraph.sdk.Transaction<TokenCreateTransaction>
com.hedera.hashgraph.sdk.TokenCreateTransaction
public class TokenCreateTransaction extends Transaction<TokenCreateTransaction>
Create an HTS token. #### Keys Each token has several keys that, separately, control different functions for that token. It is *_strongly_* recommended that each key assigned to a token be unique, or disabled by assigning an empty `KeyList`. Keys and purpose - `adminKey` is a general access and may authorize a token update transaction as well as _update the other keys_. Even the admin key cannot authorize _adding_ a key that is not present, however.
The admin key may also delete the token entirely. - `fee_schedule` may authorize updating the token custom fees. If this key is not present, the custom fees for the token are fixed and immutable. - `freeze` may authorize a token freeze or unfreeze transaction. If this key is not present, accounts holding this token cannot have their tokens frozen or unfrozen. - `kyc` may authorize a token grant KYC or revoke KYC transaction. If this key is not present, accounts holding this token cannot have KYC status granted or revoked. - `metadata` may authorize token update nfts transactions. If this key is not present, the token metadata values for that non-fungible/unique token _type_ will be immutable. - `pause` may authorize a token pause or token unpause transaction. If this key is not present, the token cannot be paused (preventing any account from transacting in that token) or resumed. - `supply` may authorize a token mint or burn transaction. If this key is not present, the token cannot mint additional supply and existing tokens cannot be "burned" from the treasury (but _might_ still be "burned" from individual accounts, c.f. `wipeKey` and `tokenWipe`). - `wipe` may authorize a token wipe account transaction. If this key is not present, accounts holding this token cannot have their balance or NFTs wiped (effectively burned). #### Requirements If `tokenType` is fungible/common, the `initialSupply` MUST be strictly greater than zero(`0`).
If `tokenType` is non-fungible/unique, the `initialSupply` MUST be zero(`0`).
If `tokenSupplyType` is "infinite", the `maxSupply` MUST be zero(`0`).
If `tokenSupplyType` is "finite", the `maxSupply` MUST be strictly greater than zero(`0`).
### Block Stream Effects If the token is created, the Token Identifier SHALL be in the receipt.

  • Constructor Details

    • TokenCreateTransaction

      public TokenCreateTransaction()
      Constructor.

    • TokenCreateTransaction

      TokenCreateTransaction(LinkedHashMap<TransactionId,LinkedHashMap<AccountId,Transaction>> txs) throws com.google.protobuf.InvalidProtocolBufferException
      Constructor.
      Parameters:
      txs - Compound list of transaction id's list of (AccountId, Transaction) records
      Throws:
      com.google.protobuf.InvalidProtocolBufferException - when there is an issue with the protobuf

    • TokenCreateTransaction

      TokenCreateTransaction(TransactionBody txBody)
      Constructor.
      Parameters:
      txBody - protobuf TransactionBody

  • Method Details

    • getTokenName

      @Nullable public String getTokenName()
      Extract the token name.
      Returns:
      the token name

    • setTokenName

      public TokenCreateTransaction setTokenName(String name)
      A name for the token.
      This is generally the "full name" displayed in wallet software.

      This field is REQUIRED.
      This value MUST NOT exceed 100 bytes when encoded as UTF-8.
      This value MUST NOT contain the Unicode NUL codepoint.

      Parameters:
      name - the token name
      Returns:
      this

    • getTokenSymbol

      public String getTokenSymbol()
      Extract the token symbol.
      Returns:
      the token symbol

    • setTokenSymbol

      public TokenCreateTransaction setTokenSymbol(String symbol)
      A symbol to use for the token.

      This field is REQUIRED.
      This value MUST NOT exceed 100 bytes when encoded as UTF-8.
      This value MUST NOT contain the Unicode NUL codepoint.

      Parameters:
      symbol - the token symbol
      Returns:
      this

    • getDecimals

      public int getDecimals()
      Extract the decimals.
      Returns:
      the decimals

    • setDecimals

      public TokenCreateTransaction setDecimals(@Nonnegative int decimals)
      A decimal precision of the token's smallest denomination.
      Most values are described in terms of this smallest denomination, so the token initial supply, for instance, must be divided by 10decimals to get whole tokens.

      This MUST be zero(`0`) for non-fungible/unique tokens.

      Parameters:
      decimals - the number of decimals
      Returns:
      this

    • getInitialSupply

      public long getInitialSupply()
      Extract the initial supply of tokens.
      Returns:
      the initial supply of tokens

    • setInitialSupply

      public TokenCreateTransaction setInitialSupply(@Nonnegative long initialSupply)
      An initial supply, in the smallest denomination for the token.

      This amount SHALL be transferred to the treasury account as part of this transaction.
      This amount MUST be specified in the smallest denomination for the token (i.e. 10-decimals whole tokens).
      This MUST be zero(`0`) for a non-fungible/unique token.

      Parameters:
      initialSupply - the initial supply of tokens
      Returns:
      this

    • getTreasuryAccountId

      @Nullable public AccountId getTreasuryAccountId()
      Extract the treasury account id.
      Returns:
      the treasury account id

    • setTreasuryAccountId

      public TokenCreateTransaction setTreasuryAccountId(AccountId accountId)
      A treasury account identifier.

      This field is REQUIRED.
      The identified account SHALL be designated the "treasury" for the new token, and all tokens "minted" SHALL be delivered to that account, including the initial supply, if any.
      The identified account MUST exist, MUST NOT be expired, and SHOULD have a non-zero HBAR balance.
      The identified account SHALL be associated to the new token.

      Parameters:
      accountId - the treasury account id
      Returns:
      this

    • getAdminKey

      @Nullable public Key getAdminKey()
      Extract the admin key.
      Returns:
      the admin key

    • setAdminKey

      public TokenCreateTransaction setAdminKey(Key key)
      An Hedera key for token administration.

      This key, if set, SHALL have administrative authority for this token and MAY authorize token update and/or token delete transactions.
      If this key is not set, or is an empty `KeyList`, this token SHALL be immutable, except for expiration and renewal.

      Parameters:
      key - the admin key
      Returns:
      this

    • getKycKey

      @Nullable public Key getKycKey()
      Extract the know your customer key.
      Returns:
      the know your customer key

    • setKycKey

      public TokenCreateTransaction setKycKey(Key key)
      An Hedera key for managing account KYC.

      This key, if set, SHALL have KYC authority for this token and MAY authorize transactions to grant or revoke KYC for accounts.
      If this key is not set, or is an empty `KeyList`, KYC status for this token SHALL NOT be granted or revoked for any account.
      If this key is removed after granting KYC, those grants SHALL remain and cannot be revoked.

      Parameters:
      key - the know your customer key
      Returns:
      this

    • getFreezeKey

      @Nullable public Key getFreezeKey()
      Extract the freeze key.
      Returns:
      the freeze key

    • setFreezeKey

      public TokenCreateTransaction setFreezeKey(Key key)
      An Hedera key for managing asset "freeze".

      This key, if set, SHALL have "freeze" authority for this token and MAY authorize transactions to freeze or unfreeze accounts with respect to this token.
      If this key is not set, or is an empty `KeyList`, this token SHALL NOT be frozen or unfrozen for any account.
      If this key is removed after freezing accounts, those accounts SHALL remain frozen and cannot be unfrozen.

      Parameters:
      key - the freeze key
      Returns:
      this

    • getWipeKey

      @Nullable public Key getWipeKey()
      Extract the wipe key.
      Returns:
      the wipe key

    • setWipeKey

      public TokenCreateTransaction setWipeKey(Key key)
      An Hedera key for wiping tokens from accounts.

      This key, if set, SHALL have "wipe" authority for this token and MAY authorize transactions to "wipe" any amount of this token from any account, effectively burning the tokens "wiped".
      If this key is not set, or is an empty `KeyList`, it SHALL NOT be possible to "wipe" this token from an account.

      Parameters:
      key - the wipe key
      Returns:
      this

    • getSupplyKey

      @Nullable public Key getSupplyKey()
      Extract the supply key.
      Returns:
      the supply key

    • setSupplyKey

      public TokenCreateTransaction setSupplyKey(Key key)
      An Hedera key for "minting" and "burning" tokens.

      This key, if set, MAY authorize transactions to "mint" new tokens to be delivered to the token treasury or "burn" tokens held by the token treasury.
      If this key is not set, or is an empty `KeyList`, it SHALL NOT be possible to change the supply of tokens and neither "mint" nor "burn" transactions SHALL be permitted.

      Parameters:
      key - the supply key
      Returns:
      this

    • getFeeScheduleKey

      @Nullable public Key getFeeScheduleKey()
      Extract the fee schedule key.
      Returns:
      the fee schedule key

    • setFeeScheduleKey

      public TokenCreateTransaction setFeeScheduleKey(Key key)
      An Hedera key for managing the token custom fee schedule.

      This key, if set, MAY authorize transactions to modify the `custom_fees` for this token.
      If this key is not set, or is an empty `KeyList`, the `custom_fees` for this token SHALL NOT be modified.

      Parameters:
      key - the fee schedule key
      Returns:
      this

    • getPauseKey

      @Nullable public Key getPauseKey()
      Extract the pause key.
      Returns:
      the pause key

    • setPauseKey

      public TokenCreateTransaction setPauseKey(Key key)
      An Hedera key for managing token "pause".

      This key, if set, SHALL have "pause" authority for this token and MAY authorize transactions to pause or unpause this token.
      If this key is not set, or is an empty `KeyList`, this token SHALL NOT be paused or unpaused.
      If this key is removed while the token is paused, the token cannot be unpaused and SHALL remain paused.

      Parameters:
      key - the pause key
      Returns:
      this

    • getMetadataKey

      @Nullable public Key getMetadataKey()
      Extract the metadata key.
      Returns:
      the metadata key

    • setMetadataKey

      public TokenCreateTransaction setMetadataKey(Key key)
      An Hedera key for managing the token `metadata`.

      This key, if set, MAY authorize transactions to modify the `metadata` for this token.
      If this key is not set, or is an empty `KeyList`, the `metadata` for this token SHALL NOT be modified.

      Parameters:
      key - the metadata key
      Returns:
      this

    • getFreezeDefault

      public boolean getFreezeDefault()
      Extract the freeze default.
      Returns:
      the freeze default

    • setFreezeDefault

      public TokenCreateTransaction setFreezeDefault(boolean freezeDefault)
      An initial Freeze status for accounts associated to this token.

      If this value is set, an account MUST be the subject of a `tokenUnfreeze` transaction after associating to the token before that account can send or receive this token.
      If this value is set, the `freezeKey` SHOULD be set.
      If the `freezeKey` is not set, any account associated to this token while this value is set SHALL be permanently frozen.

      REVIEW NOTE
      Should we prevent setting this value true for tokens with no freeze key?
      Should we set this value to false if a freeze key is removed?
      Parameters:
      freezeDefault - the freeze default
      Returns:
      this

    • getExpirationTime

      @Nullable public Instant getExpirationTime()
      Extract the expiration time.
      Returns:
      the expiration time

    • setExpirationTime

      public TokenCreateTransaction setExpirationTime(Instant expirationTime)
      An expiration timestamp.

      If the `autoRenewAccount` and `autoRenewPeriod` fields are set, this value SHALL be replaced with the current consensus time extended by the `autoRenewPeriod` duration.
      If this value is set and token expiration is enabled in network configuration, this token SHALL expire when consensus time exceeds this value, and MAY be subsequently removed from the network state.
      If this value is not set, and the automatic renewal account is also not set, then this value SHALL default to the current consensus time extended by the "default" expiration period from network configuration. Setting this value will clear the autoRenewPeriod as the autoRenewPeriod period has default value of 7890000 seconds and leaving it set will override the expiration time

      Parameters:
      expirationTime - the expiration time
      Returns:
      this

    • setExpirationTime

      public TokenCreateTransaction setExpirationTime(Duration expirationTime)

    • getAutoRenewAccountId

      @Nullable public AccountId getAutoRenewAccountId()
      Extract the auto renew account id.
      Returns:
      the auto renew account id

    • setAutoRenewAccountId

      public TokenCreateTransaction setAutoRenewAccountId(AccountId accountId)
      An identifier for the account to be charged renewal fees at the token's expiry to extend the lifetime of the token.

      If this value is set, the token lifetime SHALL be extended by the _smallest_ of the following:

      • The current `autoRenewPeriod` duration.
      • The maximum duration that this account has funds to purchase.
      • The configured MAX_AUTORENEW_PERIOD at the time of automatic renewal.
      If this account's HBAR balance is `0` when the token must be renewed, then the token SHALL be expired, and MAY be subsequently removed from state.
      If this value is set, the referenced account MUST sign this transaction.
      Parameters:
      accountId - the auto renew account id
      Returns:
      this

    • getAutoRenewPeriod

      @Nullable public Duration getAutoRenewPeriod()
      Extract the auto renew period.
      Returns:
      the auto renew period

    • setAutoRenewPeriod

      public TokenCreateTransaction setAutoRenewPeriod(Duration period)
      A duration between token automatic renewals.
      All entities in state may be charged "rent" occasionally (typically every 90 days) to prevent unnecessary growth of the ledger. This value sets the interval between such events for this token.

      This value MUST be set.
      This value MUST be greater than the configured MIN_AUTORENEW_PERIOD.
      This value MUST be less than the configured MAX_AUTORENEW_PERIOD. If expirationTime is set - autoRenewPeriod will be effectively ignored, and it's effect will be replaced by expirationTime

      Parameters:
      period - the auto renew period
      Returns:
      this

    • getTokenMemo

      public String getTokenMemo()
      Extract the token's memo 100 bytes max.
      Returns:
      the token's memo 100 bytes max

    • setTokenMemo

      public TokenCreateTransaction setTokenMemo(String memo)
      A short description for this token.

      This value, if set, MUST NOT exceed `transaction.maxMemoUtf8Bytes` (default 100) bytes when encoded as UTF-8.

      Parameters:
      memo - the token's memo 100 bytes max
      Returns:
      this

    • getCustomFees

      @Nullable public List<CustomFee> getCustomFees()
      Extract the custom fees.
      Returns:
      the custom fees

    • setCustomFees

      public TokenCreateTransaction setCustomFees(List<CustomFee> customFees)
      A list of custom fees representing a fee schedule.

      This list MAY be empty, which SHALL mean that there are no custom fees for this token.
      If this token is a non-fungible/unique type, the entries in this list MUST NOT declare a `fractional_fee`.
      If this token is a fungible/common type, the entries in this list MUST NOT declare a `royalty_fee`.
      Any token type MAY include entries that declare a `fixed_fee`.

      Parameters:
      customFees - the custom fees
      Returns:
      this

    • getTokenType

      public TokenType getTokenType()
      Extract the token type.
      Returns:
      the token type

    • setTokenType

      public TokenCreateTransaction setTokenType(TokenType tokenType)
      A type for this token, according to IWA classification.

      If this value is not set, the token SHALL have the default type of fungible/common.
      This field SHALL be immutable.

      Parameters:
      tokenType - the token type
      Returns:
      this

    • getSupplyType

      public TokenSupplyType getSupplyType()
      Extract the supply type.
      Returns:
      the supply type

    • setSupplyType

      public TokenCreateTransaction setSupplyType(TokenSupplyType supplyType)
      A supply type for this token, according to IWA classification.

      If this value is not set, the token SHALL have the default supply type of "infinite" (which is, as a practical matter, (263-1)/10decimals).
      This field SHALL be immutable.

      Parameters:
      supplyType - the supply type
      Returns:
      this

    • getMaxSupply

      public long getMaxSupply()
      Extract the max supply of tokens.
      Returns:
      the max supply of tokens

    • setMaxSupply

      public TokenCreateTransaction setMaxSupply(@Nonnegative long maxSupply)
      A maximum supply for this token.

      This SHALL be interpreted in terms of the smallest fractional unit for this token.
      If `supplyType` is "infinite", this MUST be `0`.
      This field SHALL be immutable.

      Parameters:
      maxSupply - the max supply of tokens
      Returns:
      this

    • getTokenMetadata

      public byte[] getTokenMetadata()
      Extract the token metadata.
      Returns:
      the token metadata

    • setTokenMetadata

      public TokenCreateTransaction setTokenMetadata(byte[] tokenMetadata)
      Token "Metadata".

      The value, if set, MUST NOT exceed 100 bytes.

      Examples
      hcs://1/0.0.4896575
      ipfs://bafkreifd7tcjjuwxxf4qkaibkj62pj4mhfuud7plwrc3pfoygt55al6syi
      Parameters:
      tokenMetadata - the token metadata
      Returns:
      this

    • freezeWith

      public TokenCreateTransaction freezeWith(@Nullable Client client)
      Description copied from class: Transaction
      Freeze this transaction from further modification to prepare for signing or serialization.

      Will use the `Client`, if available, to generate a default Transaction ID and select 1/3 nodes to prepare this transaction for.

      Overrides:
      freezeWith in class Transaction<TokenCreateTransaction>
      Parameters:
      client - the configured client
      Returns:
      this

    • build

      TokenCreateTransactionBody.Builder build()
      Build the transaction body.
      Returns:
      TokenCreateTransactionBody

    • initFromTransactionBody

      void initFromTransactionBody()
      Initialize from the transaction body.

    • validateChecksums

      void validateChecksums(Client client) throws BadEntityIdException
      Specified by:
      validateChecksums in class Transaction<TokenCreateTransaction>
      Throws:
      BadEntityIdException

    • getMethodDescriptor

      io.grpc.MethodDescriptor<Transaction,TransactionResponse> getMethodDescriptor()
      Description copied from class: Executable
      Called to direct the invocation of the query to the appropriate gRPC service.
      Specified by:
      getMethodDescriptor in class Executable<TokenCreateTransaction,Transaction,TransactionResponse,TransactionResponse>

    • onFreeze

      void onFreeze(TransactionBody.Builder bodyBuilder)
      Description copied from class: Transaction
      Called in Transaction.freezeWith(Client) just before the transaction body is built. The intent is for the derived class to assign their data variant to the transaction body.
      Specified by:
      onFreeze in class Transaction<TokenCreateTransaction>

    • onScheduled

      void onScheduled(SchedulableTransactionBody.Builder scheduled)
      Description copied from class: Transaction
      Called in Transaction.schedule() when converting transaction into a scheduled version.
      Specified by:
      onScheduled in class Transaction<TokenCreateTransaction>