mirror of
https://github.com/XRPLF/xrpl-dev-portal.git
synced 2025-11-20 11:45:50 +00:00
264 lines
10 KiB
Java
264 lines
10 KiB
Java
// Stand-alone code sample for the "issue a token" tutorial:
|
|
// https://xrpl.org/issue-a-fungible-token.html
|
|
// License: https://github.com/XRPLF/xrpl-dev-portal/blob/master/LICENSE
|
|
|
|
import com.fasterxml.jackson.core.JsonProcessingException;
|
|
import com.google.common.primitives.UnsignedInteger;
|
|
import com.google.common.primitives.UnsignedLong;
|
|
import okhttp3.HttpUrl;
|
|
import org.xrpl.xrpl4j.client.JsonRpcClientErrorException;
|
|
import org.xrpl.xrpl4j.client.XrplClient;
|
|
import org.xrpl.xrpl4j.client.faucet.FaucetClient;
|
|
import org.xrpl.xrpl4j.client.faucet.FundAccountRequest;
|
|
import org.xrpl.xrpl4j.crypto.KeyMetadata;
|
|
import org.xrpl.xrpl4j.crypto.PrivateKey;
|
|
import org.xrpl.xrpl4j.crypto.signing.SignatureService;
|
|
import org.xrpl.xrpl4j.crypto.signing.SignedTransaction;
|
|
import org.xrpl.xrpl4j.crypto.signing.SingleKeySignatureService;
|
|
import org.xrpl.xrpl4j.model.client.accounts.AccountInfoRequestParams;
|
|
import org.xrpl.xrpl4j.model.client.accounts.AccountLinesRequestParams;
|
|
import org.xrpl.xrpl4j.model.client.accounts.TrustLine;
|
|
import org.xrpl.xrpl4j.model.client.common.LedgerIndex;
|
|
import org.xrpl.xrpl4j.model.client.fees.FeeResult;
|
|
import org.xrpl.xrpl4j.model.client.ledger.LedgerRequestParams;
|
|
import org.xrpl.xrpl4j.model.client.transactions.TransactionRequestParams;
|
|
import org.xrpl.xrpl4j.model.client.transactions.TransactionResult;
|
|
import org.xrpl.xrpl4j.model.immutables.FluentCompareTo;
|
|
import org.xrpl.xrpl4j.model.transactions.AccountSet;
|
|
import org.xrpl.xrpl4j.model.transactions.ImmutableTrustSet;
|
|
import org.xrpl.xrpl4j.model.transactions.IssuedCurrencyAmount;
|
|
import org.xrpl.xrpl4j.model.transactions.Payment;
|
|
import org.xrpl.xrpl4j.model.transactions.TrustSet;
|
|
import org.xrpl.xrpl4j.wallet.DefaultWalletFactory;
|
|
import org.xrpl.xrpl4j.wallet.Wallet;
|
|
import org.xrpl.xrpl4j.wallet.WalletFactory;
|
|
|
|
import java.util.List;
|
|
|
|
public class IssueToken {
|
|
|
|
public static void main(String[] args)
|
|
throws InterruptedException, JsonRpcClientErrorException, JsonProcessingException {
|
|
// Construct a network client ----------------------------------------------
|
|
HttpUrl rippledUrl = HttpUrl
|
|
.get("https://s.altnet.rippletest.net:51234/");
|
|
XrplClient xrplClient = new XrplClient(rippledUrl);
|
|
// Get the current network fee
|
|
FeeResult feeResult = xrplClient.fee();
|
|
|
|
|
|
// Create cold and hot Wallets using a WalletFactory -----------------------
|
|
WalletFactory walletFactory = DefaultWalletFactory.getInstance();
|
|
Wallet coldWallet = walletFactory.randomWallet(true).wallet();
|
|
Wallet hotWallet = walletFactory.randomWallet(true).wallet();
|
|
|
|
// Fund the account using the testnet Faucet -------------------------------
|
|
FaucetClient faucetClient = FaucetClient
|
|
.construct(HttpUrl.get("https://faucet.altnet.rippletest.net"));
|
|
faucetClient.fundAccount(FundAccountRequest.of(coldWallet.classicAddress()));
|
|
faucetClient.fundAccount(FundAccountRequest.of(hotWallet.classicAddress()));
|
|
|
|
// If you go too soon, the funding transaction might slip back a ledger and
|
|
// then your starting Sequence number will be off. This is mostly relevant
|
|
// when you want to use a Testnet account right after getting a reply from
|
|
// the faucet.
|
|
boolean accountsFunded = false;
|
|
while (!accountsFunded) {
|
|
try {
|
|
xrplClient.accountInfo(
|
|
AccountInfoRequestParams.builder()
|
|
.ledgerIndex(LedgerIndex.VALIDATED)
|
|
.account(coldWallet.classicAddress())
|
|
.build()
|
|
);
|
|
|
|
xrplClient.accountInfo(
|
|
AccountInfoRequestParams.builder()
|
|
.ledgerIndex(LedgerIndex.VALIDATED)
|
|
.account(hotWallet.classicAddress())
|
|
.build()
|
|
);
|
|
|
|
accountsFunded = true;
|
|
} catch (JsonRpcClientErrorException e) {
|
|
if (!e.getMessage().equals("Account not found.")) {
|
|
throw e;
|
|
}
|
|
Thread.sleep(1000);
|
|
}
|
|
}
|
|
|
|
// Configure issuer settings -----------------------------------------------
|
|
UnsignedInteger coldWalletSequence = xrplClient.accountInfo(
|
|
AccountInfoRequestParams.builder()
|
|
.ledgerIndex(LedgerIndex.CURRENT)
|
|
.account(coldWallet.classicAddress())
|
|
.build()
|
|
).accountData().sequence();
|
|
|
|
AccountSet setDefaultRipple = AccountSet.builder()
|
|
.account(coldWallet.classicAddress())
|
|
.fee(feeResult.drops().minimumFee())
|
|
.sequence(coldWalletSequence)
|
|
.signingPublicKey(coldWallet.publicKey())
|
|
.setFlag(AccountSet.AccountSetFlag.DEFAULT_RIPPLE)
|
|
.lastLedgerSequence(computeLastLedgerSequence(xrplClient))
|
|
.build();
|
|
|
|
PrivateKey coldWalletPrivateKey = PrivateKey.fromBase16EncodedPrivateKey(
|
|
coldWallet.privateKey().get()
|
|
);
|
|
SignatureService coldWalletSignatureService = new SingleKeySignatureService(coldWalletPrivateKey);
|
|
|
|
SignedTransaction<AccountSet> signedSetDefaultRipple = coldWalletSignatureService.sign(
|
|
KeyMetadata.EMPTY,
|
|
setDefaultRipple
|
|
);
|
|
|
|
submitAndWaitForValidation(signedSetDefaultRipple, xrplClient);
|
|
|
|
// Configure hot address settings ------------------------------------------
|
|
UnsignedInteger hotWalletSequence = xrplClient.accountInfo(
|
|
AccountInfoRequestParams.builder()
|
|
.ledgerIndex(LedgerIndex.CURRENT)
|
|
.account(hotWallet.classicAddress())
|
|
.build()
|
|
).accountData().sequence();
|
|
|
|
AccountSet setRequireAuth = AccountSet.builder()
|
|
.account(hotWallet.classicAddress())
|
|
.fee(feeResult.drops().minimumFee())
|
|
.sequence(hotWalletSequence)
|
|
.signingPublicKey(hotWallet.publicKey())
|
|
.setFlag(AccountSet.AccountSetFlag.REQUIRE_AUTH)
|
|
.lastLedgerSequence(computeLastLedgerSequence(xrplClient))
|
|
.build();
|
|
|
|
PrivateKey hotWalletPrivateKey = PrivateKey.fromBase16EncodedPrivateKey(
|
|
hotWallet.privateKey().get()
|
|
);
|
|
SignatureService hotWalletSignatureService = new SingleKeySignatureService(hotWalletPrivateKey);
|
|
|
|
SignedTransaction<AccountSet> signedSetRequireAuth = hotWalletSignatureService.sign(
|
|
KeyMetadata.EMPTY,
|
|
setRequireAuth
|
|
);
|
|
|
|
submitAndWaitForValidation(signedSetRequireAuth, xrplClient);
|
|
|
|
// Create trust line -------------------------------------------------------
|
|
String currencyCode = "FOO";
|
|
ImmutableTrustSet trustSet = TrustSet.builder()
|
|
.account(hotWallet.classicAddress())
|
|
.fee(feeResult.drops().openLedgerFee())
|
|
.sequence(hotWalletSequence.plus(UnsignedInteger.ONE))
|
|
.limitAmount(IssuedCurrencyAmount.builder()
|
|
.currency(currencyCode)
|
|
.issuer(coldWallet.classicAddress())
|
|
.value("10000000000")
|
|
.build())
|
|
.signingPublicKey(hotWallet.publicKey())
|
|
.build();
|
|
|
|
SignedTransaction<TrustSet> signedTrustSet = hotWalletSignatureService.sign(
|
|
KeyMetadata.EMPTY,
|
|
trustSet
|
|
);
|
|
|
|
submitAndWaitForValidation(signedTrustSet, xrplClient);
|
|
|
|
// Send token --------------------------------------------------------------
|
|
Payment payment = Payment.builder()
|
|
.account(coldWallet.classicAddress())
|
|
.fee(feeResult.drops().openLedgerFee())
|
|
.sequence(coldWalletSequence.plus(UnsignedInteger.ONE))
|
|
.destination(hotWallet.classicAddress())
|
|
.amount(IssuedCurrencyAmount.builder()
|
|
.issuer(coldWallet.classicAddress())
|
|
.currency(currencyCode)
|
|
.value("3840")
|
|
.build())
|
|
.signingPublicKey(coldWallet.publicKey())
|
|
.build();
|
|
|
|
SignedTransaction<Payment> signedPayment = coldWalletSignatureService.sign(
|
|
KeyMetadata.EMPTY,
|
|
payment
|
|
);
|
|
|
|
submitAndWaitForValidation(signedPayment, xrplClient);
|
|
|
|
// Check balances ----------------------------------------------------------
|
|
List<TrustLine> lines = xrplClient.accountLines(
|
|
AccountLinesRequestParams.builder()
|
|
.account(hotWallet.classicAddress())
|
|
.ledgerIndex(LedgerIndex.VALIDATED)
|
|
.build()
|
|
).lines();
|
|
System.out.println("Hot wallet TrustLines: " + lines);
|
|
}
|
|
|
|
// Helper methods ------------------------------------------------------------
|
|
private static UnsignedInteger computeLastLedgerSequence(XrplClient xrplClient)
|
|
throws JsonRpcClientErrorException {
|
|
// Get the latest validated ledger index
|
|
LedgerIndex validatedLedger = xrplClient.ledger(
|
|
LedgerRequestParams.builder()
|
|
.ledgerIndex(LedgerIndex.VALIDATED)
|
|
.build()
|
|
)
|
|
.ledgerIndex()
|
|
.orElseThrow(() -> new RuntimeException("LedgerIndex not available."));
|
|
|
|
// Workaround for https://github.com/XRPLF/xrpl4j/issues/84
|
|
return UnsignedInteger.valueOf(
|
|
validatedLedger.plus(UnsignedLong.valueOf(4)).unsignedLongValue().intValue()
|
|
);
|
|
}
|
|
|
|
private static void submitAndWaitForValidation(SignedTransaction<?> signedTransaction, XrplClient xrplClient)
|
|
throws InterruptedException, JsonRpcClientErrorException, JsonProcessingException {
|
|
|
|
xrplClient.submit(signedTransaction);
|
|
|
|
boolean transactionValidated = false;
|
|
boolean transactionExpired = false;
|
|
while (!transactionValidated && !transactionExpired) {
|
|
Thread.sleep(4 * 1000);
|
|
LedgerIndex latestValidatedLedgerIndex = xrplClient.ledger(
|
|
LedgerRequestParams.builder().ledgerIndex(LedgerIndex.VALIDATED).build()
|
|
)
|
|
.ledgerIndex()
|
|
.orElseThrow(() ->
|
|
new RuntimeException("Ledger response did not contain a LedgerIndex.")
|
|
);
|
|
|
|
TransactionResult<Payment> transactionResult = xrplClient.transaction(
|
|
TransactionRequestParams.of(signedTransaction.hash()),
|
|
Payment.class
|
|
);
|
|
|
|
if (transactionResult.validated()) {
|
|
System.out.println("Transaction was validated with result code " +
|
|
transactionResult.metadata().get().transactionResult());
|
|
transactionValidated = true;
|
|
} else {
|
|
boolean lastLedgerSequenceHasPassed = FluentCompareTo.
|
|
is(latestValidatedLedgerIndex.unsignedLongValue())
|
|
.greaterThan(UnsignedLong.valueOf(
|
|
signedTransaction.signedTransaction().lastLedgerSequence().get().intValue()
|
|
)
|
|
);
|
|
if (lastLedgerSequenceHasPassed) {
|
|
System.out.println("LastLedgerSequence has passed. Last tx response: " +
|
|
transactionResult);
|
|
transactionExpired = true;
|
|
} else {
|
|
System.out.println("Transaction not yet validated.");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|