use of com.hedera.hashgraph.sdk.AccountId 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();
}
use of com.hedera.hashgraph.sdk.AccountId in project hedera-sdk-java by hashgraph.
the class DeleteAccountExample 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);
// Generate a Ed25519 private, public key pair
PrivateKey newKey = PrivateKey.generateED25519();
PublicKey newPublicKey = newKey.getPublicKey();
System.out.println("private key = " + newKey);
System.out.println("public key = " + newPublicKey);
TransactionResponse transactionResponse = new AccountCreateTransaction().setKey(newKey).setInitialBalance(new Hbar(2)).execute(client);
// This will wait for the receipt to become available
TransactionReceipt receipt = transactionResponse.getReceipt(client);
AccountId newAccountId = Objects.requireNonNull(receipt.accountId);
System.out.println("account = " + newAccountId);
new AccountDeleteTransaction().setTransactionId(TransactionId.generate(newAccountId)).setAccountId(newAccountId).setTransferAccountId(OPERATOR_ID).freezeWith(client).sign(newKey).execute(client).getReceipt(client);
}
use of com.hedera.hashgraph.sdk.AccountId in project hedera-sdk-java by hashgraph.
the class MultiSigOfflineExample method main.
public static void main(String[] args) throws PrecheckStatusException, TimeoutException, ReceiptStatusException, InvalidProtocolBufferException {
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);
PrivateKey user1Key = PrivateKey.generateED25519();
PrivateKey user2Key = PrivateKey.generateED25519();
System.out.println("private key for user 1 = " + user1Key);
System.out.println("public key for user 1 = " + user1Key.getPublicKey());
System.out.println("private key for user 2 = " + user2Key);
System.out.println("public key for user 2 = " + user2Key.getPublicKey());
// create a multi-sig account
KeyList keylist = new KeyList();
keylist.add(user1Key);
keylist.add(user2Key);
TransactionResponse createAccountTransaction = new AccountCreateTransaction().setInitialBalance(new Hbar(2)).setKey(keylist).execute(client);
@Var TransactionReceipt receipt = createAccountTransaction.getReceipt(client);
System.out.println("account id = " + receipt.accountId);
// create a transfer from new account to 0.0.3
TransferTransaction transferTransaction = new TransferTransaction().setNodeAccountIds(Collections.singletonList(new AccountId(3))).addHbarTransfer(Objects.requireNonNull(receipt.accountId), Hbar.from(-1)).addHbarTransfer(new AccountId(3), new Hbar(1)).freezeWith(client);
// convert transaction to bytes to send to signatories
byte[] transactionBytes = transferTransaction.toBytes();
Transaction<?> transactionToExecute = Transaction.fromBytes(transactionBytes);
// ask users to sign and return signature
byte[] user1Signature = user1Key.signTransaction(Transaction.fromBytes(transactionBytes));
byte[] user2Signature = user2Key.signTransaction(Transaction.fromBytes(transactionBytes));
// recreate the transaction from bytes
transactionToExecute.signWithOperator(client);
transactionToExecute.addSignature(user1Key.getPublicKey(), user1Signature);
transactionToExecute.addSignature(user2Key.getPublicKey(), user2Signature);
TransactionResponse result = transactionToExecute.execute(client);
receipt = result.getReceipt(client);
System.out.println(receipt.status);
}
use of com.hedera.hashgraph.sdk.AccountId in project hedera-mirror-node by hashgraph.
the class SDKClient method getValidatedClient.
private Client getValidatedClient(Map<String, AccountId> currentNetworkMap, Client client) throws InterruptedException {
Map<String, AccountId> validNodes = new LinkedHashMap<>();
for (var nodeEntry : currentNetworkMap.entrySet()) {
try {
if (validateNode(nodeEntry.getValue().toString(), client)) {
validNodes.putIfAbsent(nodeEntry.getKey(), nodeEntry.getValue());
log.trace("Added node {} at endpoint {} to list of valid nodes", nodeEntry.getValue(), nodeEntry.getKey());
}
} catch (Exception e) {
//
}
}
log.info("{} of {} nodes are reachable", validNodes.size(), currentNetworkMap.size());
if (validNodes.size() == 0) {
throw new IllegalStateException("All provided nodes are unreachable!");
}
log.info("Creating validated client using nodes: {} nodes", validNodes);
Client validatedClient = Client.forNetwork(validNodes);
validatedClient.setOperator(expandedOperatorAccountId.getAccountId(), expandedOperatorAccountId.getPrivateKey());
validatedClient.setMirrorNetwork(List.of(mirrorNodeAddress));
return validatedClient;
}
use of com.hedera.hashgraph.sdk.AccountId in project hedera-mirror-node by hashgraph.
the class SDKClient method getAddressBookNetworkMap.
private Map<String, AccountId> getAddressBookNetworkMap(Client client) throws InvalidProtocolBufferException, PrecheckStatusException, TimeoutException {
NodeAddressBook addressBook = getAddressBookFromNetwork(client);
Map<String, AccountId> networkMap = new HashMap<>();
for (NodeAddress nodeAddressProto : addressBook.getNodeAddressList()) {
networkMap.putIfAbsent(String.format("%s:%d", nodeAddressProto.getIpAddress().toStringUtf8(), nodeAddressProto.getPortno()), new AccountId(nodeAddressProto.getNodeAccountId().getShardNum(), nodeAddressProto.getNodeAccountId().getRealmNum(), nodeAddressProto.getNodeAccountId().getAccountNum()));
}
log.debug("Obtained addressBook networkMap: {}", networkMap);
return networkMap;
}
Aggregations