Examples with TokenId com.hedera.hashgraph.sdk.TokenId used on opensource projects

Example 1 with TokenId

use of com.hedera.hashgraph.sdk.TokenId in project hedera-sdk-java by hashgraph.

the class TransferTokensExample method main.

public static void main(String[] args) throws Exception {
    Client client = Client.forName(HEDERA_NETWORK);
    // Defaults the operator account ID and key such that all generated transactions will be paid for
    // by this account and be signed by this key
    client.setOperator(OPERATOR_ID, OPERATOR_KEY);
    // Generate a Ed25519 private, public key pair
    PrivateKey key1 = PrivateKey.generateED25519();
    PrivateKey key2 = PrivateKey.generateED25519();
    System.out.println("private key = " + key1);
    System.out.println("public key = " + key1.getPublicKey());
    System.out.println("private key = " + key2);
    System.out.println("public key = " + key2.getPublicKey());
    @Var TransactionResponse response = new AccountCreateTransaction().setKey(key1.getPublicKey()).setInitialBalance(Hbar.fromTinybars(1000)).execute(client);
    // This will wait for the receipt to become available
    @Var TransactionReceipt receipt = response.getReceipt(client);
    AccountId accountId1 = Objects.requireNonNull(receipt.accountId);
    System.out.println("accountId1 = " + accountId1);
    response = new AccountCreateTransaction().setKey(key2.getPublicKey()).setInitialBalance(Hbar.fromTinybars(1000)).execute(client);
    // This will wait for the receipt to become available
    receipt = response.getReceipt(client);
    AccountId accountId2 = Objects.requireNonNull(receipt.accountId);
    System.out.println("accountId2 = " + accountId1);
    response = new TokenCreateTransaction().setNodeAccountIds(Collections.singletonList(response.nodeId)).setTokenName("ffff").setTokenSymbol("F").setDecimals(3).setInitialSupply(1000000).setTreasuryAccountId(OPERATOR_ID).setAdminKey(OPERATOR_KEY.getPublicKey()).setFreezeKey(OPERATOR_KEY.getPublicKey()).setWipeKey(OPERATOR_KEY.getPublicKey()).setKycKey(OPERATOR_KEY.getPublicKey()).setSupplyKey(OPERATOR_KEY.getPublicKey()).setFreezeDefault(false).execute(client);
    TokenId tokenId = Objects.requireNonNull(response.getReceipt(client).tokenId);
    System.out.println("token = " + tokenId);
    new TokenAssociateTransaction().setNodeAccountIds(Collections.singletonList(response.nodeId)).setAccountId(accountId1).setTokenIds(Collections.singletonList(tokenId)).freezeWith(client).sign(OPERATOR_KEY).sign(key1).execute(client).getReceipt(client);
    System.out.println("Associated account " + accountId1 + " with token " + tokenId);
    new TokenAssociateTransaction().setNodeAccountIds(Collections.singletonList(response.nodeId)).setAccountId(accountId2).setTokenIds(Collections.singletonList(tokenId)).freezeWith(client).sign(OPERATOR_KEY).sign(key2).execute(client).getReceipt(client);
    System.out.println("Associated account " + accountId2 + " with token " + tokenId);
    new TokenGrantKycTransaction().setNodeAccountIds(Collections.singletonList(response.nodeId)).setAccountId(accountId1).setTokenId(tokenId).execute(client).getReceipt(client);
    System.out.println("Granted KYC for account " + accountId1 + " on token " + tokenId);
    new TokenGrantKycTransaction().setNodeAccountIds(Collections.singletonList(response.nodeId)).setAccountId(accountId2).setTokenId(tokenId).execute(client).getReceipt(client);
    System.out.println("Granted KYC for account " + accountId2 + " on token " + tokenId);
    new TransferTransaction().setNodeAccountIds(Collections.singletonList(response.nodeId)).addTokenTransfer(tokenId, OPERATOR_ID, -10).addTokenTransfer(tokenId, accountId1, 10).execute(client).getReceipt(client);
    System.out.println("Sent 10 tokens from account " + OPERATOR_ID + " to account " + accountId1 + " on token " + tokenId);
    new TransferTransaction().setNodeAccountIds(Collections.singletonList(response.nodeId)).addTokenTransfer(tokenId, accountId1, -10).addTokenTransfer(tokenId, accountId2, 10).freezeWith(client).sign(key1).execute(client).getReceipt(client);
    System.out.println("Sent 10 tokens from account " + accountId1 + " to account " + accountId2 + " on token " + tokenId);
    new TransferTransaction().setNodeAccountIds(Collections.singletonList(response.nodeId)).addTokenTransfer(tokenId, accountId2, -10).addTokenTransfer(tokenId, accountId1, 10).freezeWith(client).sign(key2).execute(client).getReceipt(client);
    System.out.println("Sent 10 tokens from account " + accountId2 + " to account " + accountId1 + " on token " + tokenId);
    new TokenWipeTransaction().setNodeAccountIds(Collections.singletonList(response.nodeId)).setTokenId(tokenId).setAccountId(accountId1).setAmount(10).execute(client).getReceipt(client);
    System.out.println("Wiped balance of account " + accountId1);
    new TokenDeleteTransaction().setNodeAccountIds(Collections.singletonList(response.nodeId)).setTokenId(tokenId).execute(client).getReceipt(client);
    System.out.println("Deleted token " + tokenId);
    new AccountDeleteTransaction().setAccountId(accountId1).setTransferAccountId(OPERATOR_ID).freezeWith(client).sign(OPERATOR_KEY).sign(key1).execute(client).getReceipt(client);
    System.out.println("Deleted accountId1 " + accountId1);
    new AccountDeleteTransaction().setAccountId(accountId2).setTransferAccountId(OPERATOR_ID).freezeWith(client).sign(OPERATOR_KEY).sign(key2).execute(client).getReceipt(client);
    System.out.println("Deleted accountId2" + accountId2);
}

Example 2 with TokenId

use of com.hedera.hashgraph.sdk.TokenId in project hedera-sdk-java by hashgraph.

the class CustomFeesExample method main.

public static void main(String[] args) throws TimeoutException, PrecheckStatusException, ReceiptStatusException {
    Client client = Client.forName(HEDERA_NETWORK);
    // Defaults the operator account ID and key such that all generated transactions will be paid for
    // by this account and be signed by this key
    client.setOperator(OPERATOR_ID, OPERATOR_KEY);
    // Create three accounts, Alice, Bob, and Charlie.  Alice will be the treasury for our example token.
    // Fees only apply in transactions not involving the treasury, so we need two other accounts.
    PrivateKey aliceKey = PrivateKey.generateED25519();
    AccountId aliceId = new AccountCreateTransaction().setInitialBalance(new Hbar(10)).setKey(aliceKey).freezeWith(client).sign(aliceKey).execute(client).getReceipt(client).accountId;
    PrivateKey bobKey = PrivateKey.generateED25519();
    AccountId bobId = new AccountCreateTransaction().setInitialBalance(new Hbar(10)).setKey(bobKey).freezeWith(client).sign(bobKey).execute(client).getReceipt(client).accountId;
    PrivateKey charlieKey = PrivateKey.generateED25519();
    AccountId charlieId = new AccountCreateTransaction().setInitialBalance(new Hbar(10)).setKey(charlieKey).freezeWith(client).sign(charlieKey).execute(client).getReceipt(client).accountId;
    System.out.println("Alice: " + aliceId);
    System.out.println("Bob: " + bobId);
    System.out.println("Charlie: " + charlieId);
    // Let's start with a custom fee list of 1 fixed fee.  A custom fee list can be a list of up to
    // 10 custom fees, where each fee is a fixed fee or a fractional fee.
    // This fixed fee will mean that every time Bob transfers any number of tokens to Charlie,
    // Alice will collect 1 Hbar from each account involved in the transaction who is SENDING
    // the Token (in this case, Bob).
    CustomFixedFee customHbarFee = new CustomFixedFee().setHbarAmount(new Hbar(1)).setFeeCollectorAccountId(aliceId);
    List<CustomFee> hbarFeeList = Collections.singletonList(customHbarFee);
    // In this example the fee is in Hbar, but you can charge a fixed fee in a token if you'd like.
    // EG, you can make it so that each time an account transfers Foo tokens,
    // they must pay a fee in Bar tokens to the fee collecting account.
    // To charge a fixed fee in tokens, instead of calling setHbarAmount(), call
    // setDenominatingTokenId(tokenForFee) and setAmount(tokenFeeAmount).
    // Setting the feeScheduleKey to Alice's key will enable Alice to change the custom
    // fees list on this token later using the TokenFeeScheduleUpdateTransaction.
    // We will create an initial supply of 100 of these tokens.
    TokenId tokenId = new TokenCreateTransaction().setTokenName("Example Token").setTokenSymbol("EX").setAdminKey(aliceKey).setSupplyKey(aliceKey).setFeeScheduleKey(aliceKey).setTreasuryAccountId(aliceId).setCustomFees(hbarFeeList).setInitialSupply(100).freezeWith(client).sign(aliceKey).execute(client).getReceipt(client).tokenId;
    System.out.println("Token: " + tokenId);
    TokenInfo tokenInfo1 = new TokenInfoQuery().setTokenId(tokenId).execute(client);
    System.out.println("Custom Fees according to TokenInfoQuery:");
    System.out.println(tokenInfo1.customFees);
    // We must associate the token with Bob and Charlie before they can trade in it.
    new TokenAssociateTransaction().setAccountId(bobId).setTokenIds(Collections.singletonList(tokenId)).freezeWith(client).sign(bobKey).execute(client).getReceipt(client);
    new TokenAssociateTransaction().setAccountId(charlieId).setTokenIds(Collections.singletonList(tokenId)).freezeWith(client).sign(charlieKey).execute(client).getReceipt(client);
    // give all 100 tokens to Bob
    new TransferTransaction().addTokenTransfer(tokenId, bobId, 100).addTokenTransfer(tokenId, aliceId, -100).freezeWith(client).sign(aliceKey).execute(client).getReceipt(client);
    Hbar aliceHbar1 = new AccountBalanceQuery().setAccountId(aliceId).execute(client).hbars;
    System.out.println("Alice's Hbar balance before Bob transfers 20 tokens to Charlie: " + aliceHbar1);
    TransactionRecord record1 = new TransferTransaction().addTokenTransfer(tokenId, bobId, -20).addTokenTransfer(tokenId, charlieId, 20).freezeWith(client).sign(bobKey).execute(client).getRecord(client);
    Hbar aliceHbar2 = new AccountBalanceQuery().setAccountId(aliceId).execute(client).hbars;
    System.out.println("Alices's Hbar balance after Bob transfers 20 tokens to Charlie: " + aliceHbar2);
    System.out.println("Assessed fees according to transaction record:");
    System.out.println(record1.assessedCustomFees);
    // Let's use the TokenUpdateFeeScheduleTransaction with Alice's key to change the custom fees on our token.
    // TokenUpdateFeeScheduleTransaction will replace the list of fees that apply to the token with
    // an entirely new list.  Let's charge a 10% fractional fee.  This means that when Bob attempts to transfer
    // 20 tokens to Charlie, 10% of the tokens he attempts to transfer (2 in this case) will be transferred to
    // Alice instead.
    // Fractional fees default to FeeAssessmentMethod.INCLUSIVE, which is the behavior described above.
    // If you set the assessment method to EXCLUSIVE, then when Bob attempts to transfer 20 tokens to Charlie,
    // Charlie will receive all 20 tokens, and Bob will be charged an _additional_ 10% fee which
    // will be transferred to Alice.
    CustomFractionalFee customFractionalFee = new CustomFractionalFee().setNumerator(1).setDenominator(10).setMin(1).setMax(10).setFeeCollectorAccountId(aliceId);
    List<CustomFee> fractionalFeeList = Collections.singletonList(customFractionalFee);
    new TokenFeeScheduleUpdateTransaction().setTokenId(tokenId).setCustomFees(fractionalFeeList).freezeWith(client).sign(aliceKey).execute(client).getReceipt(client);
    TokenInfo tokenInfo2 = new TokenInfoQuery().setTokenId(tokenId).execute(client);
    System.out.println("Custom Fees according to TokenInfoQuery:");
    System.out.println(tokenInfo2.customFees);
    Map<TokenId, Long> aliceTokens3 = new AccountBalanceQuery().setAccountId(aliceId).execute(client).tokens;
    System.out.println("Alice's token balance before Bob transfers 20 tokens to Charlie: " + aliceTokens3);
    TransactionRecord record2 = new TransferTransaction().addTokenTransfer(tokenId, bobId, -20).addTokenTransfer(tokenId, charlieId, 20).freezeWith(client).sign(bobKey).execute(client).getRecord(client);
    Map<TokenId, Long> aliceTokens4 = new AccountBalanceQuery().setAccountId(aliceId).execute(client).tokens;
    System.out.println("Alices's token balance after Bob transfers 20 tokens to Charlie: " + aliceTokens4);
    System.out.println("Token transfers according to transaction record:");
    System.out.println(record2.tokenTransfers);
    System.out.println("Assessed fees according to transaction record:");
    System.out.println(record2.assessedCustomFees);
    // clean up
    new TokenDeleteTransaction().setTokenId(tokenId).freezeWith(client).sign(aliceKey).execute(client).getReceipt(client);
    new AccountDeleteTransaction().setAccountId(charlieId).setTransferAccountId(client.getOperatorAccountId()).freezeWith(client).sign(charlieKey).execute(client).getReceipt(client);
    new AccountDeleteTransaction().setAccountId(bobId).setTransferAccountId(client.getOperatorAccountId()).freezeWith(client).sign(bobKey).execute(client).getReceipt(client);
    new AccountDeleteTransaction().setAccountId(aliceId).setTransferAccountId(client.getOperatorAccountId()).freezeWith(client).sign(aliceKey).execute(client).getReceipt(client);
    client.close();
}

Example 3 with TokenId

use of com.hedera.hashgraph.sdk.TokenId in project hedera-mirror-node by hashgraph.

the class TokenFeature method verifyMirrorNftTransactionsAPIResponses.

@Then("^the mirror node REST API should return status (.*) for token (:?(.*) )?serial number " + "(:?(.*) )?transaction flow$")
@Retryable(value = { AssertionError.class }, backoff = @Backoff(delayExpression = "#{@restPollingProperties.minBackoff.toMillis()}"), maxAttemptsExpression = "#{@restPollingProperties.maxAttempts}")
public void verifyMirrorNftTransactionsAPIResponses(int status, Integer tokenIndex, Integer serialNumberIndex) {
    TokenId tokenId = tokenIds.get(getIndexOrDefault(tokenIndex));
    Long serialNumber = tokenSerialNumbers.get(tokenId).get(getIndexOrDefault(serialNumberIndex));
    verifyTransactions(status);
    verifyNftTransactions(tokenId, serialNumber);
    publishBackgroundMessages();
}

Example 4 with TokenId

use of com.hedera.hashgraph.sdk.TokenId in project hedera-mirror-node by hashgraph.

the class TokenFeature method cleanup.

@After
public void cleanup() {
    // dissociate all applicable accounts from token to reduce likelihood of max token association error
    for (TokenId tokenId : tokenIds) {
        // a nonzero balance will result in a TRANSACTION_REQUIRES_ZERO_TOKEN_BALANCES error
        // not possible to wipe a treasury account as it results in CANNOT_WIPE_TOKEN_TREASURY_ACCOUNT error
        // as a result to dissociate first delete token
        ExpandedAccountId admin = tokenClient.getSdkClient().getExpandedOperatorAccountId();
        try {
            tokenClient.delete(admin, tokenId);
            dissociateAccounts(tokenId, List.of(admin));
            dissociateAccounts(tokenId, recipients);
            dissociateAccounts(tokenId, senders);
        } catch (Exception ex) {
            log.warn("Error cleaning up token {} and associations error: {}", tokenId, ex);
        }
    }
    recipients.clear();
    senders.clear();
    tokenCustomFees.clear();
    tokenIds.clear();
    tokenSerialNumbers.clear();
}

Example 5 with TokenId

use of com.hedera.hashgraph.sdk.TokenId in project hedera-mirror-node by hashgraph.

the class TokenFeature method updateTokenFeeSchedule.

@Given("I update token {int} with new custom fees schedule")
public void updateTokenFeeSchedule(int tokenIndex, List<CustomFee> customFees) {
    ExpandedAccountId admin = tokenClient.getSdkClient().getExpandedOperatorAccountId();
    TokenId tokenId = tokenIds.get(tokenIndex);
    networkTransactionResponse = tokenClient.updateTokenFeeSchedule(tokenId, admin, customFees);
    assertNotNull(networkTransactionResponse.getTransactionId());
    assertNotNull(networkTransactionResponse.getReceipt());
    tokenCustomFees.put(tokenId, customFees);
}