Ein Blockchain-Projekt unter der Leitung von VISA Nur die Edition mit dem Namen Chain Core Developer Edition ist Open Source. Bitte lesen Sie den Artikel über den Bauvorgang bis zum Aufbau der Kettenumgebung. Aufbau der Kettenumgebung
Bitte beachten Sie den Beispielcode im Dokument auf der offiziellen Seite. https://chain.com/docs/core/get-started/introduction
Wenn Sie sich den Beispielcode, den Javadoc- und den SDK-Quellcode ansehen, sollten Sie grundsätzlich wissen, was zu tun ist.
Verträge etc. wurden noch nicht umgesetzt.
Informationen wie ausgeführte Transaktionen und erstellte Konten können auch im Dashboard bestätigt werden, das angezeigt wird, indem mit einem Browser auf den 1999-Port des Servers zugegriffen wird, auf dem Chain ausgeführt wird.
Im Großen und Ganzen werden Suchanfragen ausgeführt und Transaktionen wie Überweisungen ausgeführt. Ein Schlüssel zur Authentifizierung ist nicht erforderlich, um eine Abfrage auszuführen, aber ein Authentifizierungsschlüssel ist erforderlich, um eine API auszuführen, die Transaktionen wie Auszahlungen generiert.
Sie können auch die interne ID usw. in Kette sehen, Die meisten werden durch Definieren eines Alias (Alias) in Währung, Konto usw. erstellt. Abfragen und Transaktionen werden ebenfalls mit einem Alias ausgeführt.
Notieren Sie sich die URL, den Port und den Zugriffsschlüssel des Servers, auf dem Chain ausgeführt wird.
public static final String TARGET_URL = "http://XX.XXX.XX.XXX:1999/";
public static final String TOKEN = "client:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
public static final String KEY_ALIAS = "test";
Generieren Sie zunächst eine Client-Klasse, um eine Verbindung zum Server herzustellen.
Client client = new Client(TARGET_URL,TOKEN);
Wenn Sie eine Suchabfrage ausführen möchten, benötigen Sie nur den Client. Wenn Sie jedoch eine Transaktion ausführen möchten, müssen Sie den folgenden Authentifizierungsschlüssel festlegen.
MockHsm.Key key = null;
MockHsm.Key.Items keys = new MockHsm.Key.QueryBuilder().addAlias(ApiSettings.KEY_ALIAS).execute(client);
if (keys.hasNext()){
key = keys.next();
}else{
key = MockHsm.Key.create(client,ApiSettings.KEY_ALIAS);
}
HsmSigner.addKey(key, MockHsm.getSignerClient(client));
Wenn der beim Erstellen dieses Authentifizierungsschlüssels angegebene Alias unterschiedlich ist, tritt ein Authentifizierungsfehler auf und es kann kein Geld gesendet werden. Der zum Erstellen des Überweisungskontos verwendete Schlüssel muss auch zur Authentifizierung der Überweisungstransaktion verwendet werden.
MockHsm.Key key = MockHsm.Key.create(client);
Wenn Sie einen Schlüssel erstellen, ohne einen Alias wie anzugeben, wird eine unbegrenzte Anzahl anonymer Schlüssel erstellt. Geben Sie daher beim Erstellen einen Alias wie unten gezeigt an und erstellen Sie ihn mit einem bestimmten Schlüssel.
MockHsm.Key key = MockHsm.Key.create(client,ApiSettings.KEY_ALIAS);
Dadurch kann der erstellte Schlüssel durch Abfrage abgerufen und wiederverwendet werden. Wenn Sie jedoch keinen Alias angeben, können Sie den Schlüssel, der zur Authentifizierung des Kontos bei der Ausführung einer Transaktion erforderlich ist, nicht explizit angeben. Erstellen Sie anschließend ein Konto, definieren Sie Vermögenswerte (Währung) und überweisen Sie Geld.
Es dient nur als Referenz, aber wenn Sie das Beispiel auf der offiziellen Seite so verwenden, wie es ist, treten Fehler bei der Handhabung der Authentifizierung auf.
@Service
public class AccountService extends BaseService {
private static final Logger LOGGER = LoggerFactory.getLogger(AccountService.class.getName());
public String create(String account) throws ChainException{
Client client = createClient();
MockHsm.Key key = createKey(client);
HsmSigner.addKey(key, MockHsm.getSignerClient(client));
Account.Items accounts = new Account.QueryBuilder()
.setFilter("alias=$1")
.addFilterParameter(account)
.execute(client);
Account created = null;
if (accounts.hasNext()){
created = accounts.next();
LOGGER.info("account is exists.");
}else{
created = new Account.Builder()
.setAlias(account)
.addRootXpub(key.xpub)
.setQuorum(1)
.create(client);
LOGGER.info("account created.");
}
return created.alias;
}
}
Hier ist BaseService wie folgt.
@Service
public class BaseService {
/**
*Holen Sie sich einen Verbindungsclient
* @return client
* @throws ChainException
*/
protected Client createClient() throws ChainException{
return new Client(ApiSettings.TARGET_URL,ApiSettings.TOKEN);
}
/**
*Holen Sie sich einen gemeinsamen Authentifizierungsschlüssel
* @param client
* @return key
* @throws ChainException
*/
protected MockHsm.Key createKey(Client client) throws ChainException{
MockHsm.Key key = null;
MockHsm.Key.Items keys = new MockHsm.Key.QueryBuilder().addAlias(ApiSettings.KEY_ALIAS).execute(client);
if (keys.hasNext()){
key = keys.next();
}else{
key = MockHsm.Key.create(client,ApiSettings.KEY_ALIAS);
}
return key;
}
}
Zuerst verwende ich den Abfrage-Generator, um nach einem Konto zu suchen.
Account.Items accounts = new Account.QueryBuilder()
.setFilter("alias=$1")
.addFilterParameter(account)
.execute(client);
Alle Hauptklassen wie Account, Asset, Balance und MockHsm.Key verfügen über ** QueryBuilder () ** -Methoden. Sie können auf ähnliche Weise suchen.
Geben Sie in ** setFilter ("Bedingung") ** die Suchbedingung als Zeichenfolge an. Die Bedingungen, die hier angegeben werden können, sind auf der Seite API-Objekt der offiziellen Dokumentationsreferenz beschrieben. https://chain.com/docs/core/reference/api-objects
Geben Sie im nächsten ** addFilterParameter (Konto) ** die von setFilter angegebene Zeichenfolge an, die in ** \ $ 1, $ 2 ** eingebettet werden soll. Hier wird die als Argument übergebene Zeichenfolge (Alias) für den Kontonamen angegeben. Führen Sie nach dem Einstellen des Filters mit execute aus.
Die Abfrage wird auf der folgenden Seite beschrieben. https://chain.com/docs/core/build-applications/queries
Das Ergebnis wird von einem Iterator wie Account.Items und Balance.Items zurückgegeben.
if (accounts.hasNext()){
created = accounts.next();
Ich habe es bei erhalten.
Dies ist zum Beispiel
while (balances.hasNext()) {
Balance b = balances.next();
LOGGER.info("balance of " + b.sumBy.get("asset_alias") + ": " + b.amount);
}
Sobald Sie es mit drehen, während Sie mögen
assets.forEachRemaining(s -> {
assetList.add(new AssetDto(s.id,s.alias));
});
Sie können es mit Lambda wie drehen.
Wenn keine Suchergebnisse vorhanden sind, wird ein neues Konto erstellt.
created = new Account.Builder()
.setAlias(account)
.addRootXpub(key.xpub)
.setQuorum(1)
.create(client);
LOGGER.info("account created.");
Der während dieses Vorgangs verwendete MockHsm.Key ist der im Voraus erstellte Schlüssel, aber derselbe Schlüssel muss zum Ausführen von Transaktionen verwendet werden, die sich auf dieses Konto beziehen. Es sollte für jedes Konto erstellt werden. Da die Verwaltung jedoch kompliziert ist, wird hier ein gemeinsamer Schlüssel (Alias) verwendet.
Hier führen wir eine Transaktion aus. Gleichzeitig mit der Generierung der Währung wird die Währung an das angegebene Konto übergeben. Eingabe und Ausgabe sind immer eine Menge.
Definieren Sie die Währung in der Aktion ** Ausgabe ** und Die Aktion ** ControlWithAccount ** übergibt die generierte Währung an das angegebene Konto.
@Service
public class IssueService extends BaseService {
private static final Logger LOGGER = LoggerFactory.getLogger(IssueService.class.getName());
public void issue(String assetName,String issueAccount,Long amount) throws ChainException{
Client client = createClient();
MockHsm.Key key = createKey(client);
HsmSigner.addKey(key, MockHsm.getSignerClient(client));
//Generieren Sie, wenn die Währung von AssetName nicht definiert ist.
if (!isExistAsset(assetName,client)){
new Asset.Builder()
.setAlias(assetName)
.addRootXpub(key.xpub)
.setQuorum(1)
.create(client);
}
//Währungsdefinitionstransaktion.
//Von der Issue-Aktion bis zur ControlWithAccount-Aktion wird der Betrag der AssetName-Währung auf das IssueAccount verteilt.
Transaction.Template issuanceToProgram = new Transaction.Builder()
.addAction(new Transaction.Action.Issue()
.setAssetAlias(assetName)
.setAmount(amount)
).addAction(new Transaction.Action.ControlWithAccount()
.setAccountAlias(issueAccount)
.setAssetAlias(assetName)
.setAmount(amount)
).build(client);
//Signieren und Ausführen von Transaktionen
Transaction.Template signedIssuanceToProgram = HsmSigner.sign(issuanceToProgram);
Transaction.submit(client, signedIssuanceToProgram);
}
private boolean isExistAsset(String assetName,Client client) throws ChainException {
Asset.Items assets = new Asset.QueryBuilder()
.setFilter("alias=$1")
.addFilterParameter(assetName)
.execute(client);
if (assets.hasNext()){
return true;
}
return false;
}
}
Geschrieben wie jede andere Abfrage.
@Service
public class AssetQueryService extends BaseService {
public List<AssetDto> getAssetList(String assetName) throws ChainException {
Client client = createClient();
Asset.Items assets = new Asset.QueryBuilder()
.setFilter("alias=$1")
.addFilterParameter(assetName)
.execute(client);
List<AssetDto> assetList = new ArrayList<>();
assets.forEachRemaining(s -> {
assetList.add(new AssetDto(s.id,s.alias));
});
return assetList;
}
}
Dies wird ebenfalls auf die gleiche Weise geschrieben, außer dass die Balance-Klasse verwendet wird. Im folgenden Beispiel werden zwei Suchparameter verwendet.
@Service
public class BalanceService extends BaseService {
private static final Logger LOGGER = LoggerFactory
.getLogger(BalanceService.class.getName());
public ResponseBalanceDto getBalance(String assetName, String account)
throws ChainException {
Client client = createClient();
Balance.Items balances = new Balance.QueryBuilder()
.setFilter("account_alias=$1 AND asset_alias=$2")
.addFilterParameter(account)
.addFilterParameter(assetName)
.execute(client);
Balance balance = null;
ResponseBalanceDto responseDto = new ResponseBalanceDto();
if (balances.hasNext()){
balance = balances.next();
responseDto.setBalance(balance.amount);
LOGGER.info("account:{} asset:{} amount:{} ",account,assetName,balance.amount);
}
return responseDto;
}
}
Ziehen Sie mit der Aktion ** SpendFromAccount ** die Währung vom Absender ab und Die Aktion ** ControlWithAccount ** übergibt die Währung an den Empfänger. Achten Sie auf Schlüssel usw., da die Transaktion nicht nur über einen Alias ausgeführt wird.
@Service
public class TransferService extends BaseService {
private static final Logger LOGGER = LoggerFactory.getLogger(TransferService.class.getName());
/**
*Überweisungsausführung
* @Parameter aus dem Quellkonto der Überweisung
* @Parameter zum Konto Überweisungskonto
* @param assetName Währungsname
* @param betrag betrag
* @throws ChainException
*/
public void transfer(String fromAccount, String toAccount,
String assetName, Long amount) throws ChainException {
Client client = createClient();
MockHsm.Key key = createKey(client);
HsmSigner.addKey(key, MockHsm.getSignerClient(client));
Transaction.Template transfertran = new Transaction.Builder()
.addAction(
new Transaction.Action.SpendFromAccount()
.setAccountAlias(fromAccount)
.setAssetAlias(assetName).setAmount(amount))
.addAction(
new Transaction.Action.ControlWithAccount()
.setAccountAlias(toAccount)
.setAssetAlias(assetName).setAmount(amount))
.build(client);
Transaction.Template signedTransfertran = HsmSigner.sign(transfertran);
Transaction.submit(client, signedTransfertran);
}
}
key Chain,blockchain,API
Recommended Posts