Open in app

Sign in

Write

Sign in

[Caver] Klaytn-Kontoschlüssel Updaten mit Caver #3 AccountKeyRoleBased

Tech at Klaytn
9 min readOct 8, 2021

--

Hier ist die komplette Liste aller Artikel.

🇰🇷:[Caver] Caver로 Klaytn 계정의 키를 바꾸는 방법 #3 AccountKeyRoleBased
🇬🇧:[Caver] How to Update Klaytn Account Keys with Caver #3 AccountKeyRoleBased
🇫🇷: [Caver] Mettre à jour la clé de compte de Klaytn avec Caver #3 AccountKeyRoleBased

Eines der erwähnenswerten Features der Klaytn Blockchain ist die Entkopplung der Schlüssel von den Adressen. Das heißt, dass Ihre Kontoschlüssel upgedatet werden können. In diesem Post, erklären wir Ihnen wie man mit caver-js and caver-java Kontoschlüssel auf AccountKeyRoleBased updaten kann. Weitere Details zu den verschiedenen Typen von AccountKey finden Sie in Klaytn Docs.

Bevor es mit diesem Tutorial los geht, müssen Sie die geeignete Umgebungseinrichtung konfiguriert haben. Wenn Sie das noch nicht haben, besuchen Sie zuerst diesen Link: caver-js — Prerequisites or caver-java — Prerequisites.

In jedem Abschnitt behandeln wir kleine Schnipsel des ganzen Codes. Die komplette Version finden sich hier:

1. keyring generieren

Zuallererst müssen wir ein Klaytn-Konto erstellen. Dieses Konto muss dann auch über genügend KLAY verfügen, weil es zum Senden der Transaktionen für das Update der Schlüssel notwendig ist.

Caver hat eine Struktur namens Keyring, der die Privatschlüssel speichert, die für Klaytn-Konto und -Adressen eingesetzt werden.

Unten sehen Sie wie man in caver-js eine Keyring-Instanz erzeugen kann.

// caver-js
const senderKeyring = caver.wallet.keyring.create(senderAddress, senderPrivateKey)

Falls Sie eine keystore-Datei anstatt eines Privatschlüssel-Strings haben, benutzen Siecaver.wallet.keyring.decrypt zur Erzeugung eines Keyring.

Und das Erstellen einer Keyring-Instanz in caver-java erfolgt wie unten gezeigt:

// caver-java
SingleKeyring senderKeyring = caver.wallet.keyring.create(senderAddress, senderPrivateKey);

Sie können auch für caver-javacaver.wallet.keyring.decrypt benutzen falls Sie eine keystore Datei haben.

2. keyring zum caver-In-Memory-Wallet hinzufügen

In diesem Tutorial, benutzen wir eine In-Memory-Wallet. Nachdem Sie einen Keyring zu caver-In-Memory-Wallet hinzugefügt haben, der darin gespeicherte Schlüssel wird automatisch von nun an eingesetzt um die Transaktionen zu signieren, selbst wenn Sie das nicht explizit festsetzen.

So fügen Sie einen Keyring zur In-Memory-Wallet mit caver-js:

// caver-js
caver.wallet.add(senderKeyring)

Der Prozess ist derselbe mit caver-java:

// caver-java
caver.wallet.add(senderKeyring);

3. Creating a new private key

Wenn Sie den AccountKey Ihres Klaytn-Kontos in AccountKeyRoleBased verändern wollen, benötigen Sie Privatschlüssel, die je nach ihren Rollen definiert sind. Hier verwenden wir die Schlüssel, der mit der Funktion generateRoleBasedKeyszufällig generiert sind. Aber wenn Sie sich für bestimmte Schlüssel, die je nach Rollen definiert sind, entscheiden wollen, ist das auch völlig in Ordnung. Weitere Details zu den Rollen finden sich in Klaytn Docs.

Unten sehen Sie wie man für Ihr Klaytn-Konto neue Privatschlüssel-Strings erstellen kann mit caver-js. Das Array, das als Parameter übergeben ist, definiert die Anzahl der Schlüssel, die für jede Rolle benötigt wird. Der Beispielcode unten wird zwei RoleTransactionKeys, einen RoleAccountUpdateKey, und drei RoleFeePayerKeys generieren.

// caver-js
const newRoleBasedKeys = caver.wallet.keyring.generateRoleBasedKeys([2, 1, 3])

Sie können auch Privatschlüssel-Strings erzeugen in caver-java mit generateRoleBasedKeys:

List<String[]> newRoleBasedKeys = caver.wallet.keyring.generateRolBasedKeys(new int[]{2, 1, 3});

4. Neuen keyring erstellen

Da wir jetzt neue Privatschlüssel erstellt haben, werden wir nun eine Keyring Instanz erzeugen, um diese Schlüssel mit ihren definierten Rollen. Wir können die Instanz mit den neuen Schlüsseln erst verwenden, nachdem AccountKey im Klaytn-Konto erfolgreich verändert ist.

Sie erstellen die Keyring Instanz mit den Privatschlüsseln caver-js wie im Folgenden gezeigt:

// caver-js
const newKeyring = caver.wallet.keyring.create(senderKeyring.address, newRoleBasedKeys)

Der newKeyring, der den neuen Privatschlüssel speichert, wird von nun an zum Signieren von Transaktionen newRoleBasedKeys verwenden.

In caver-java, das Erstellen von einer Keyring-Instanz, die die neuen Privatschlüssel speichert, sieht aus wie im Folgenden Beispiel.

RoleBasedKeyring newKeyring = caver.wallet.keyring.create(senderKeyring.getAddress(), newRoleBasedKeys);

5. Account-Instanz erstellen

Die Klasse Account zur Verfügung gestellt von caver beinhaltet die notwendigen Informationen für das Konto-Update. Was Sie brauchen beim Updaten auf AccountKeyRoleBased sind: die Klaytn-Kontoadresse und die auf Rollen basierten Schlüssel, bei denen die Schlüssel je nach Rollen definiert sind. In AccountKeyRoleBased werden die Schlüssel als öffentliche Schlüssel gespeichert. Wenn mehrere Schlüssel für eine Rolle verwendet werden, können Sie auch die threshold (Schwelle) und weights (Gewichte) der jeweiligen öffentlichen Schlüssel definieren.

Sie können eine Account Intanz erzeugen, indem Sie die toAccount Funktion des keyrings aufrufen, der die neuen Privatschlüssel speichert. So sieht das aus mit caver-js:

// caver-js
const account = newKeyring.toAccount([{ threshold: 2, weights: [1, 1] }, {}, { threshold: 3, weights: [2, 1, 1] }])

Der newKeyring hat zwei RoleTransaction-Schlüssel und drei RoleFeePayer-Schlüssel. Die Schwelle und die Gewichte der Schlüssel können definiert werden. Beim Aufruf von der toAccount Funktion, übergeben Sie als Parameter das Objekt, das für die jeweilige Rolle WeightedMultisigOptions definiert. Das erste Element dieses Arrays ist das Objekt, das die Schwelle und die Gewichte der zwei Schlüssel (RoleTransactionKey), definiert. Und da es nur ein Schlüssel als RoleAccountUpdateKey verwendet wird, muss ein leeres Objekt als zweite Element übergeben werden. Das letzte Array ist ein Objekt, das die Schwelle, und die Gewichte der drei Schlüssel (RoleFeePayerKey), definiert.

Sie können auch mit caver-java eine Account-Instanz erstellen durch Aufruf von der toAccount Funktion des keyrings, der die neuen, nach Rollen definierten Privatschlüssel speichert. Die Schwelle von AccountKeyRoleBased und die Gewichte der Schlüssel sind mit der WeightedMultiSigOptions Klasse definiert.

// caver-java
BigInteger[][] optionWeight = {
 {BigInteger.ONE, BigInteger.ONE},
 {},
 {BigInteger.valueOf(2), BigInteger.ONE, BigInteger.ONE},
};WeightedMultiSigOptions[] options = {
 new WeightedMultiSigOptions(BigInteger.valueOf(2), Arrays.asList(optionWeight[0])),
 new WeightedMultiSigOptions(),
 new WeightedMultiSigOptions(BigInteger.valueOf(3), Arrays.asList(optionWeight[2])),
};Account account = newKeyring.toAccount(Arrays.asList(options));

Mit caver-java können Sie auch eine Account-Instanz erstellen, indem Sie ein Array, in dem WeightedMultiSigOptions für die jeweiligen Rollen definiert sind, an dietoAccount Funktion übergeben.

Die Account Intanz beinhaltet nun die Klaytn-Kontoadresse, die zu updaten ist, und die Schlüssel mit ihren Rollen in der Form von öffentlichen Schlüsseln. Die Schwelle sowie die Gewichte der jeweiligen Schlüssel sind auch gespeichert.

6. Transaktion erstellen

Wir haben gerade eine Account-Intanz erzeugt. Nun wird sie verwendet, um eine Update-Transaktion zu erstellen.

So erstellt man eine Update-Transaktion mit caver-js:

// caver-js
const accountUpdate = caver.transaction.accountUpdate.create({
   from: senderKeyring.address,
   account: account,
   gas: 150000,})

Und mit caver-java sieht das so aus:

// caver-java
AccountUpdate accountUpdate = caver.transaction.accountUpdate.create(
    TxPropertyBuilder.accountUpdate()
        .setFrom(senderKeyring.getAddress())
        .setAccount(account)
        .setGas(BigInteger.valueOf(150000))
);

7. Transaktion signieren

Sie haben die Update-Transaktion erstellt, die Sie nun signieren müssen, und zwar mit dem keyring, der zur In-Memory Wallet hinzugefügt wurde. Cavers In-Memory Wallet, caver.wallet, hat für diesen Zweck eine sign Funktion.

Und so signieren Sie eine Transaktion mit caver-js:

// caver-js
await caver.wallet.sign(senderKeyring.address, accountUpdate)

Und mit caver-java:

// caver-java
caver.wallet.sign(senderKeyring.getAddress(), accountUpdate);

Wenn caver.wallet.sign erfolgreich durchgeführt ist, werden Sie sehen, dass nun die Signatur dem signatures Feld von accountUpdate zugewiesen ist.

Alles, was uns noch bleibt, ist die Transaktion ans Netzwerk zu übermitteln!

8. Transaktion schicken

Wir haben die Transaktion erstellt und signiert. Lass uns sie nun ans Netzwerk übermitteln. Ab dem Punkt, an dem diese Transaktion erst im Netzwerk verarbeitet ist, können Sie Ihren alten Klaytn-Kontoschlüssel nicht mehr verwenden. Weil Ihr alten keyring auch unbrauchbar wird, werden Sie einen Neuen erstellen müssen, der die neuen Privatschlüssel speichert.

Sie schicken die signierte Transaktion ans Netzwerk mit caver.rpc.klay.sendRawTransaction.

Der Code unten zeigt wie Sie mit caver-js eine Transaktion senden können, indem Sie EventEmitter verwenden:

// caver-js
caver.rpc.klay.sendRawTransaction(accountUpdate)
 .on(‘transactionHash’, hash => {
 console.log(hash)
 })
 .on(‘receipt’, receipt => {
 console.log(receipt)
 })

Mit caver-js, können Sie ein Receipt der Transaktion erhalten mit Promise, wie unten gezeigt:

// caver-js
const receipt = await caver.rpc.klay.sendRawTransaction(accountUpdate)

Sie können auch caver-java verwenden:

// caver-java
Bytes32 sendResult = caver.rpc.klay.sendRawTransaction(accountUpdate).send();
String txHash = sendResult.getResult();

Wenn dieser Code durchgeführt ist, erhalten Sie einen Hashwert der Transaktion. Das Ergebnis der Transaktion können Sie mit dem Code unten erhalten:

// caver-java
public String objectToString(Object value) throws JsonProcessingException {
    ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
    return ow.writeValueAsString(value);
}TransactionReceiptProcessor receiptProcessor = new PollingTransactionReceiptProcessor(caver, 1000, 15);TransactionReceipt.TransactionReceiptData receiptData = receiptProcessor.waitForTransactionReceipt(txHash);System.out.println(objectToString(receiptData));

Wenn im Receipt der Status true ausgegeben hat, bedeutet das, dass die Transaktion erfolgreich verarbeitet ist. Der Transaktion-Typ ist TxTypeAccountUpdate und der upgedatet AccountKeyRoleBased ist im Feld key ausgegeben in enkodierter Form.

{
 blockHash: ‘0xe1a010ffef58727d47ed34d071a523c21a661f0c50a0074f8ec2bb8389bf7775’,
 blockNumber: ‘0x33ca958’,
 contractAddress: null,
 from: ‘0x344de28e3e3089c3d7b9076f30dbbafcb329176f’,
 gas: ‘0x249f0’,
 gasPrice: ‘0x5d21dba00’,
 gasUsed: ‘0x226c8’,
 key: ‘0x05f8e8b84e04f84b01f848e301a102e2b8b818b0668e26651ed7fa199eccdc9b77e40775db80db6391244175ad6e5ee301a1033c79532bdd5b2c7265754df31f3665ed13a8556c24525a69cf0eedbbf5ff7ef1a302a102670a11eba2c17d92c01dfe272263db6c6d3eed5b1119401f9a62b7023cde6a6ab87204f86f01f86ce301a102104b2f85f43abc7b295cfd3ce91f6cb2c68e47c76d4bcc765b28c6ef2e0a86e8e301a1021190e282cf2a5066013784e08e29fb7821b3044a5f500059575bc003e926528be301a10289a57b9501c831e6b41537d3adbcaeca07ad5685d2963601b282def87ee619f2’,
 logs: [],
 logsBloom: ‘0x00000…’,
 nonce: ‘0x0’,
 senderTxHash: ‘0x826e5fbe3f33fd19c9a07b0f315eda2066ce2150b17656825e926374d32ef39a’,
 signatures: [
 { V: ‘0x7f5’, R: ‘0xa952b…’, S: ‘0x936ad…’ }
 ],
 status: ‘0x1’,
 transactionHash: ‘0x826e5fbe3f33fd19c9a07b0f315eda2066ce2150b17656825e926374d32ef39a’,
 transactionIndex: ‘0x0’,
 type: ‘TxTypeAccountUpdate’,
 typeInt: 32
}

9. Update-Ergebnis bestätigen

Wenn die Transaktion erfolgreich war, der Kontoschlüssel, der im Netzwerk gespeichert ist, wird upgedatet sein. Sie können das Ergebnis bestätigen mit caver.rpc.klay.getAccountKey.

Bestätigen Sie Ihren neuen accountKey in caver-js:

// caver-js
const accountKey = await caver.rpc.klay.getAccountKey(senderKeyring.address)console.log(accountKey)

Und mit caver-java:

// caver-java
AccountKey accountKey = caver.rpc.klay.getAccountKey(senderKeyring.getAddress()).send();System.out.println(objectToString(accountKey));

Der Code oben wird den Kontoschlüssel im Klaytn-Konto ausgeben. Der Schlüssel soll auf AccountKeyRoleBased upgedatet sein, also der keyType, der für eine Schlüsseltyp-ID steht, ist 5. Weitere Details über Kontoschlüsseltyp-IDs können Sie in Klaytn Docs finden.

{
keyType: 5,
key: [
   {
      keyType: 4,
      key: {
      threshold: 1,
      keys: [
        {
            weight: 1,
            key: { x: ‘0xe2b8b…’, y: ‘0xc8004…’ }
        },
        {
            weight: 1,
            key: { x: ‘0x3c795…’, y: ‘0x18799…’ }
        }
       ]
     }
   },
   {
    keyType: 2,
    key: { x: ‘0x670a1…’, y: ‘0x1fe76…’ }
    },
    {
    keyType: 4,
    key: {
       threshold: 1,
       keys: [
          {
              weight: 1,
              key: { x: ‘0x104b2…’, y: ‘0xa388d…’ }
          },
          {
              weight: 1,
              key: { x: ‘0x1190e…’, y: ‘0x3c23b…’ }
          },
          {
              weight: 1,
              key: { x: ‘0x89a57…’, y: ‘0xfedd0…’ }
          }
        ]
      }
    }
  ]
}

10. keyring der In-Memory Wallet updaten

Nachdem Ihr Kontoschlüssel durch eine erfolgreiche Transaktion richtig upgedatet ist, müssen Sie von nun an den upgedateten Schlüssel verwenden, um die Transaktionen zu signieren.

Im Moment ist der Schlüssel, der im keyring verwendet wird, und in der In-Memory-Wallet gespeichert ist, noch in der alten Version. Wenn Sie eine Transaktion sendet, ohne die Schlüssel in der In-Memory-Wallet upzudaten, wird das einen Fehler verursachen, wie unten gezeigt :

Error: Returned error: invalid transaction v, r, s values of the sender

Aus diesem Grund müssen Sie den Schlüssel in keyring, der in der In-Memory-Wallet gespeichert ist, auch updaten, nach dem Kontoschlüssel-Update.

Dieser Privatschlüssel kann mit caver.wallet.updateKeyring upgedatet werden. Der newKeyring, der die upgedatete Klaytn-Kontoadresse und die neue Privatschlüssel beinhaltet, wird als Parameter übergeben.

Unten sehen Sie wie das mit caver-js gemacht wird:

// caver-js
caver.wallet.updateKeyring(newKeyring)

Und nun mit caver-java:

// caver-java
caver.wallet.updateKeyring(newKeyring);

11. Transaktion schicken mit dem neuen Konto

Ihr Klaytn-Kontoschlüssel ist upgedatet; lass uns nun eine Transaktion schicken mit dem upgedateten Konto.

Weil der im Netzwerk gespeicherte Kontoschlüssel upgedatet ist, müssen Sie jetzt die Transaktion signieren mit dem neuen Schlüssel. Im Abschnitt [10. keyring der In-Memory Wallet updaten] haben wir den Schlüssel im keyring in der In-Memory-Wallet ebenfalls upgedatet. Wenn also eine Transaktion gesendet wird, wird sie mit diesem upgedateten Schlüssel signiert.

In diesem Tutorial senden wir eine einfache Value Transfer (Wertübertragung)-Transaktion um das Update zu bestätigen.

Der Code unten zeigt wir man mit caver-js eine valueTransfer-Transaktion erstellt, signiert und übermittelt.

// caver-js
const vt = caver.transaction.valueTransfer.create({
   from: senderKeyring.address,
   to: recipientAddress,
   value: 1,
   gas: 100000,
})await caver.wallet.sign(senderKeyring.address, vt)const vtReceipt = await caver.rpc.klay.sendRawTransaction(vt)

Die Transaktion wird durch caver.transaction.valueTransfer erstellt, und durch die Funktion caver.wallet.sign signiert, wie schon erklärt. Da der keyring in der In-Memory caver.wallet auch upgedatet wurde in [10. keyring der In-Memory Wallet updaten], die Transaktion wird mit den neuen Privatschlüsseln signiert. Hier signiert der Sender eine ValueTransfer-Transaktion, weshalb die Privatschlüssel, die als RoleTransaction definiert sind, verwendet werden. Danach wird die signierte Transaktion ans Netzwerk übermittelt mit caver.rpc.klay.sendRawTransaction. In diesem Beispiel ist das Ergebnis der Transaktion mit Promise ausgegeben.

Nun derselbe Prozess in caver-java:

// caver-javaValueTransfer vt = caver.transaction.valueTransfer.create(
    TxPropertyBuilder.valueTransfer()
        .setFrom(senderKeyring.getAddress())
        .setTo(recipientAddress)
        .setValue(BigInteger.valueOf(1))
        .setGas(BigInteger.valueOf(100000))
);caver.wallet.sign(senderKeyring.getAddress(), vt);Bytes32 vtResult = caver.rpc.klay.sendRawTransaction(vt).send();TransactionReceipt.TransactionReceiptData vtReceiptData = receiptProcessor.waitForTransactionReceipt(vtResult.getResult());

Erstellen Sie eine ValueTransfer-Transaktion und signieren Sie sie mit dercaver.wallet.sign Funktion. Die Transaktion wird ans Netzwerk gesendet durch Aufruf von caver.rpc.klay.sendRawTransaction. Den Transaktionsstatus können Sie abrufen mit dem ausgegebenen Hash.

In diesem Post haben wir Ihnen gezeigt, wie man einen Kontoschlüssel auf AccountKeyRoleBased updaten kann.

Das war der letzter Beitrag der Reihe <Updates von Klaytn-Kontoschlüsseln>. Wir kommen bald wieder mit einem neuen Thema.

Danke und Tschüß!

Quellcode aus dem Beitrag:

Bei Fragen wenden Sie sich an unser Developer Forum. 😉

Technology
Blockchain
Klaytn
Programmieren
Caver

--

--

Tech at Klaytn

Written by Tech at Klaytn

545 Followers

Introducing Klaytn technology

Help

Status

About

Careers

Press

Blog

Privacy

Terms

Text to speech

Teams