시작하기
이 문서는 caver-js 1.5.0 또는 상위 버전을 사용하는 개발자를 위해 작성되었습니다. 하위 버전을 사용 중이라면 Getting Started (~v1.4.1)를 확인하십시오.

준비 사항

의존성

caver-js 라이브러리를 사용하려면 다음 패키지가 필요합니다.
참고 caver-js는 Node.js 버전 12와 14에서 실행 가능합니다. 권장되는 버전은 다음과 같습니다.
다른 버전의 Node(가령 Node v15)를 사용 중인 경우, Node Version Manager(NVM)를 사용해 caver-js가 지원하는 버전을 설치하고 사용합니다.

설치

다음 명령을 사용해 npm으로 caver-js를 설치하세요:
1
$ npm install caver-js
Copied!
참고: package.json 파일이 설치 경로와 동일한 곳에 존재해야 합니다. 만일 존재하지 않으면, npm init을 통해 package.json가 생성될 수 있습니다.
caver-js의 특정 버전을 설치하려면 다음 명령을 이용하세요:
1
$ npm install [email protected]
Copied!

빠른 시작: KLAY 전송하기

이 장은 keystore file을 사용해 KLAY를 전송하는 간단한 KLAY 전송 트랜잭션 예시를 설명합니다. 키스토어 파일은 Klaytn Wallet에 생성될 수 있습니다. 테스트를 위해 KLAY가 필요한 경우 Klaytn Wallet에서 Baobab testnet KLAY를 얻을 수 있습니다.
1
const fs = require('fs')
2
const Caver = require('./index')
3
const caver = new Caver('https://your.en.url:8651/')
4
5
async function testFunction() {
6
// Read keystore json file
7
const keystore = fs.readFileSync('./keystore.json', 'utf8')
8
9
// Decrypt keystore
10
const keyring = caver.wallet.keyring.decrypt(keystore, 'password')
11
console.log(keyring)
12
13
// Add to caver.wallet
14
caver.wallet.add(keyring)
15
16
// Create value transfer transaction
17
const vt = caver.transaction.valueTransfer.create({
18
from: keyring.address,
19
to: '0x8084fed6b1847448c24692470fc3b2ed87f9eb47',
20
value: caver.utils.toPeb(1, 'KLAY'),
21
gas: 25000,
22
})
23
24
// Sign to the transaction
25
const signed = await caver.wallet.sign(keyring.address, vt)
26
27
// Send transaction to the Klaytn blockchain platform (Klaytn)
28
const receipt = await caver.rpc.klay.sendRawTransaction(signed)
29
console.log(receipt)
30
}
31
32
testFunction()
Copied!

caver-js 시작하기

caver-js 설치가 끝나면 이제 caver-js를 사용해 Klaytn 노드에 접속할 수 있습니다.
예제를 실습하려면, 먼저 아래처럼 작업 디렉토리에 테스트 파일을 생성하세요.
1
$ touch test.js
Copied!
작업 디렉토리에 생성된 test.js 파일을 확인할 수 있을 것입니다.
test.js에 다음 코드를 작성하세요.
1
// test.js
2
const Caver = require('caver-js')
3
const caver = new Caver('https://your.en.url:8651/')
4
5
async function testFunction() {
6
const version = await caver.rpc.klay.getClientVersion()
7
console.log(version)
8
}
9
10
testFunction()
Copied!
위 코드를 실행하면 아래 결과를 얻습니다.
1
$ node ./test.js
2
Klaytn/v1.4.0/linux-amd64/go1.14.1
Copied!
위와 같이 console.log 출력을 확인했다면, 아래 단계로 진행하세요. 접속한 Klaytn 노드 버전에 따라 버전 넘버가 다를 수 있습니다.

Klaytn 노드에 접속하기

아래 예시와 같이 caver-js 모듈을 가져와 Baobab 테스트넷의 Klaytn 노드에 연결할 수 있습니다:
1
const Caver = require('caver-js')
2
const caver = new Caver('https://your.en.url:8651/')
Copied!
EN을 실행 중인 경우, 아래와 같이 호스트와 포트를 변경하여 자신의 노드에 연결할 수 있습니다:
1
const Caver = require('caver-js')
2
const caver = new Caver('http://localhost:8551/')
Copied!

Keyring 관리

Keyring is a structure that contains the address of the Klaytn account and the private key(s).
Keyring can be classified into three types depending on the type of key being stored: SingleKeyring to store one address and one private key, MultipleKeyring to store one address and multiple private keys, and RoleBasedKeyring to store one address and one or more private keys for each role.
SingleKeyring defines key property inside, and this key store one private key.
MultipleKeyring defines keys property inside, and this keys is implemented as an array to store multiple private keys.
The keys property defined in RoleBasedKeyring is implemented as a two-dimensional array (empty keys will look like [ [], [], [] ]) that can include multiple keys for each role. The first element of the array is filled with the private key(s) to be used for roleTransactionKey, the second element the private key(s) to be used for roleAccountUpdateKey, and the third element the private key(s) to be used for roleFeePayerKey.

Keyring 생성

SingleKeyring 생성

아래와 같이 임의의 값을 사용해 SingleKeyring을 생성할 수 있습니다.
1
// test.js
2
const Caver = require('caver-js')
3
const caver = new Caver('https://your.en.url:8651/')
4
5
async function testFunction() {
6
const keyring = caver.wallet.keyring.generate()
7
console.log(keyring)
8
}
9
10
testFunction()
Copied!
위 코드를 실행하면 아래 결과를 얻습니다.
1
$ node ./test.js
2
SingleKeyring {
3
_address: '0x3d263c3c0df60c5516f932d244531742f45eed5c',
4
_key: PrivateKey { _privateKey: '0x{private key}' }
5
}
Copied!
실행 결과는 아래와 같습니다. 인스턴스 멤버 변수들은 keyring.addresskeyring.key로 접근 가능합니다.

개인키로 SingleKeyring 생성하기

개인키가 있다면, 이 개인키를 사용해 Keyring을 만들 수 있습니다.
1
// test.js
2
const Caver = require('caver-js')
3
const caver = new Caver('https://your.en.url:8651/')
4
5
async function testFunction() {
6
// Create a keyring from a private key
7
const keyringFromPrivateKey = caver.wallet.keyring.createFromPrivateKey('0x{private key}')
8
console.log(keyringFromPrivateKey)
9
}
10
11
testFunction()
Copied!
위 코드를 실행하면 아래 결과를 얻습니다.
1
$ node ./test.js
2
SingleKeyring {
3
_address: '0xf5a9079f311f9ec55170af351627aff0c5d2e287',
4
_key: PrivateKey { _privateKey: '0x{private key}' }
5
}
Copied!
The result of caver.wallet.keyring.createFromPrivateKey, like the result of caver.wallet.keyring.generate above, is a SingleKeyring instance with an address defined inside it and a [PrivateKey] instance in keyring.key.

개인키와 계정 주소로 SingleKeyring 생성하기

여러분의 Klaytn 계정 주소가 개인키로부터 생성된 것이 아니라 개인키와 별도로 분리된 것이라면, 주소와 개인키를 사용해 Keyring을 만들 수 있습니다.
1
// test.js
2
const Caver = require('caver-js')
3
const caver = new Caver('https://your.en.url:8651/')
4
5
async function testFunction() {
6
// Create a keyring with an address and a private key
7
const keyring = caver.wallet.keyring.createWithSingleKey('0x{address in hex}', '0x{private key}')
8
console.log(keyring)
9
10
// Create a keyring from a KlaytnWalletKey
11
const keyringFromKlaytnWalletKey = caver.wallet.keyring.createFromKlaytnWalletKey('0x{private key}0x{type}0x{address in hex}')
12
console.log(keyringFromKlaytnWalletKey)
13
}
14
15
testFunction()
Copied!
콘솔에서 아래 코드를 실행하세요.
1
$ node ./test.js
2
SingleKeyring {
3
_address: '0x17e7531b40ad5d7b5fa7b4ec78df64ce1cb36d24',
4
_key: PrivateKey { _privateKey: '0x{private key}' }
5
}
6
SingleKeyring {
7
_address: '0x17e7531b40ad5d7b5fa7b4ec78df64ce1cb36d24',
8
_key: PrivateKey { _privateKey: '0x{private key}' }
9
}
Copied!

여러 개인키로 MultipleKeyring 생성하기

If you want to use multiple private keys, you can create a MultipleKeyring using an address and multiple private keys. The below examples show how to create a MultipleKeyring with multiple private keys.
1
// test.js
2
const Caver = require('caver-js')
3
const caver = new Caver('https://your.en.url:8651/')
4
5
async function testFunction() {
6
// Create a keyring with an address and private keys
7
const keyring = caver.wallet.keyring.createWithMultipleKey('0x{address in hex}', [ '0x{private key1}', '0x{private key2}' ])
8
console.log(keyring)
9
}
10
11
testFunction()
Copied!
위 코드를 실행하면 아래 결과를 얻습니다.
1
$ node ./test.js
2
MultipleKeyring {
3
_address: '0x17e7531b40ad5d7b5fa7b4ec78df64ce1cb36d24',
4
_keys: [
5
PrivateKey { _privateKey: '0x{private key1}' },
6
PrivateKey { _privateKey: '0x{private key2}' }
7
]
8
}
Copied!
위에서 확인할 수 있듯이 _keys 속성은 여러 PrivateKey 인스턴스가 들어있는 배열을 갖고 있습니다. 인스턴스 멤버 변수들은 keyring.addresskeyring.keys로 접근 가능합니다.

개인키로 RoleBasedKeyring 생성하기

To use different private key(s) for each role, caver.wallet.keyring.createWithRoleBasedKey is used instead. Each array element represents a role described in RoleBasedKeyring. The example below shows how to create a RoleBasedKeyring instance from different keys for each role.
1
// test.js
2
const Caver = require('caver-js')
3
const caver = new Caver('https://your.en.url:8651/')
4
5
async function testFunction() {
6
// Create a keyring with an address and private keys defined by each roles
7
const keyring = caver.wallet.keyring.createWithRoleBasedKey('0x{address in hex}', [
8
[ '0x{private key1}', '0x{private key2}', '0x{private key3}' ],
9
[ '0x{private key4}'],
10
[ '0x{private key5}', '0x{private key6}' ],
11
])
12
console.log(keyring)
13
}
14
15
testFunction()
Copied!
위 코드를 실행하면 아래 결과를 얻습니다.
1
$ node ./test.js
2
RoleBasedKeyring {
3
_address: '0x17e7531b40ad5d7b5fa7b4ec78df64ce1cb36d24',
4
_keys: [
5
[
6
PrivateKey { _privateKey: '0x{private key1}' },
7
PrivateKey { _privateKey: '0x{private key2}' },
8
PrivateKey { _privateKey: '0x{private key3}' }
9
],
10
[ PrivateKey { _privateKey: '0x{private key4}' } ],
11
[
12
PrivateKey { _privateKey: '0x{private key5}' },
13
PrivateKey { _privateKey: '0x{private key6}' }
14
]
15
]
16
}
Copied!
위 결과를 살펴보면, keys 배열의 1번째 원소인 roleTransactionKey는 PrivateKey 인스턴스 3개를 가지고 있고, 2번째 원소인 roleAccountUpdateKey는 PrivateKey 인스턴스 1개를 가지고 있습니다. 그리고 배열의 마지막 원소인 roleFeePayerKey는 PrivateKey 인스턴스 2개를 가지고 있습니다.
Note: Calling functions related to keyring (caver.wallet.keyring) or wallet (caver.wallet) do not affect the actual Klaytn blockchain platform (Klaytn).

caver-js에 Keyring 추가하기

caver-js에서 제공하는 인메모리 지갑을 사용하면 쉽게 Keyring을 사용할 수 있습니다. 다음 예시는 Keyring 인스턴스 및 Klaytn Wallet이 생성한 키스토어 파일을 사용해 지갑에 Keyring을 추가하는 방법을 보여줍니다.
1
// test.js
2
const Caver = require('caver-js')
3
const caver = new Caver('https://your.en.url:8651/')
4
5
async function testFunction() {
6
// Using a keyring instance
7
const keyring = caver.wallet.keyring.generate()
8
caver.wallet.add(keyring)
9
console.log(caver.wallet.getKeyring(keyring.address))
10
11
// Using a keystore file
12
const decrypted = caver.wallet.keyring.decrypt({
13
version: 4,
14
id: '9c12de05-0153-41c7-a8b7-849472eb5de7',
15
address: '0xc02cec4d0346bf4124deeb55c5216a4138a40a8c',
16
keyring: [
17
{
18
ciphertext: 'eacf496cea5e80eca291251b3743bf93cdbcf7072efc3a74efeaf518e2796b15',
19
cipherparams: { iv: 'd688a4319342e872cefcf51aef3ec2da' },
20
cipher: 'aes-128-ctr',
21
kdf: 'scrypt',
22
kdfparams: {
23
dklen: 32,
24
salt: 'c3cee502c7157e0faa42386c6d666116ffcdf093c345166c502e23bc34e6ba40',
25
n: 4096,
26
r: 8,
27
p: 1
28
},
29
mac: '4b49574f3d3356fa0d04f73e07d5a2a6bbfdd185bedfa31f37f347bc98f2ef26'
30
}
31
]
32
}, 'password')
33
34
caver.wallet.add(decrypted)
35
console.log(caver.wallet.getKeyring(decrypted.address))
36
}
37
38
testFunction()
Copied!
콘솔에서 아래 코드를 실행하세요.
1
$ node ./test.js
2
SingleKeyring {
3
_address: '0x66391720b488a3fb2c7c69d99cd4cd6e23ca18e3',
4
_key: PrivateKey { _privateKey: '0x{private key}' }
5
}
6
SingleKeyring {
7
_address: '0xc02cec4d0346bf4124deeb55c5216a4138a40a8c',
8
_key: PrivateKey { _privateKey: '0x{private key}' }
9
}
Copied!
위 결과를 살펴보면 caver.wallet에 Keyring을 추가하면 caver.wallet에서 여러분의 Keyring을 조회할 수 있습니다.
If you have an address and private key(s) to use, you can easily create a keyring and add it directly to caver.wallet via caver.wallet.newKeyring.
1
// test.js
2
const Caver = require('caver-js')
3
const caver = new Caver('https://your.en.url:8651/')
4
5
async function testFunction() {
6
// Add to wallet with an address and a private key
7
const addedSingle = caver.wallet.newKeyring('0x{address in hex}', '0x{private key1}')
8
console.log(caver.wallet.getKeyring(addedSingle.address))
9
10
// Add to wallet with an address and private keys
11
const addedMultiple = caver.wallet.newKeyring('0x{address in hex}', ['0x{private key2}', '0x{private key3}', '0x{private key4}'])
12
console.log(caver.wallet.getKeyring(addedMultiple.address))
13
14
// Add to wallet with an address and private keys defined by each roles
15
const addedRoleBased = caver.wallet.newKeyring('0x{address in hex}', [
16
['0x{private key5}', '0x{private key6}', '0x{private key7}'],
17
['0x{private key8}', '0x{private key9}'],
18
['0x{private key10}', '0x{private key11}']
19
])
20
console.log(caver.wallet.getKeyring(addedRoleBased.address))
21
}
22
23
testFunction()
Copied!
위 코드를 실행하면 아래 결과를 얻습니다. 위 코드 실행 결과는 아래와 같습니다. 개인키를 사용해 caver.wallet.newKeyring을 실행하면 개인키 1개를 가진 Keyring 인스턴스 1개가 생성되고 이 인스턴스는 caver.wallet에 추가됩니다. 여러 개인키를 사용하면 여러 개인키를 가지는 Keyring 인스턴스 1개가 생성됩니다. When passing one or more private keys for each role as arguments, a Keyring instance with a different private key(s) for each role is created and also added to the caver.wallet.
1
$ node ./test.js
2
SingleKeyring {
3
_address: '0x651f6ae6b45750082b22805583acc989399c6552',
4
_key: PrivateKey { _privateKey: '0x{private key1}' }
5
}
6
MultipleKeyring {
7
_address: '0xce3ee92aeb4d600a41c98bdf92e8b337e186bf58',
8
_keys: [
9
PrivateKey { _privateKey: '0x{private key2}' },
10
PrivateKey { _privateKey: '0x{private key3}' },
11
PrivateKey { _privateKey: '0x{private key4}' }
12
]
13
}
14
RoleBasedKeyring {
15
_address: '0x626d5b94ec76a105c5afa370bb7e59050a22b8b5',
16
_keys: [
17
[
18
PrivateKey { _privateKey: '0x{private key5}' },
19
PrivateKey { _privateKey: '0x{private key6}' },
20
PrivateKey { _privateKey: '0x{private key7}' }
21
],
22
[
23
PrivateKey { _privateKey: '0x{private key8}' },
24
PrivateKey { _privateKey: '0x{private key9}' }
25
],
26
[
27
PrivateKey { _privateKey: '0x{private key10}' },
28
PrivateKey { _privateKey: '0x{private key11}' }
29
]
30
]
31
}
Copied!
caver.wallet에 Keyring 인스턴스를 추가하면 caver.wallet.add 또는 caver.wallet.newKeyring은 Keyring 인스턴스를 반환합니다.

트랜잭션 전송

이 장에서는 Baobab 네트워크에서 caver-js를 사용하여 KLAY를 보내는 방법을 보여줍니다.

Baobab Faucet을 통해 KLAY 받기

테스트를 위해 KLAY가 필요한 경우 Klaytn Wallet에서 Baobab testnet KLAY를 얻을 수 있습니다. 개인키 또는 키스토어 파일을 사용하여 Klaytn Wallet에 로그인하고 테스트를 위해 faucet을 통해 Baobab 테스트넷 KLAY를 받습니다.

송금 트랜잭션 전송

트랜잭션 서명은 caver-js 지갑을 통해 할 수 있습니다. 트랜잭션을 네트워크에 보내려면 아래와 같이 2단계를 거쳐야합니다.
    1.
    트랜잭션 서명하기
      If the keyring you want to use is added to caver.wallet, you can use caver.wallet.sign function to sign.
      caver.wallet에 Keyring을 추가하지 않고 따로 관리한다면, transaction.sign 함수를 통해 트랜잭션에 서명할 수 있습니다.
    2.
    RLP 인코딩된 서명된 트랜잭션을 caver.rpc.klay.sendRawTransaction을 통해 Klaytn에 전송합니다.
참고: 발신자의 잔액은 송금하려는 KLAY보다 많아야 합니다.

트랜잭션 서명하기

트랜잭션을 Klaytn에 보내기 전에 트랜잭션에 먼저 서명해야 합니다.
Below is an example of how to sign a transaction if a keyring is added to the caver.wallet.
1
// test.js
2
const Caver = require('caver-js')
3
const caver = new Caver('https://your.en.url:8651/')
4
5
async function testFunction() {
6
// Add a keyring to caver.wallet
7
const keyring = caver.wallet.keyring.createFromPrivateKey('0x{private key}')
8
caver.wallet.add(keyring)
9
10
// Create a value transfer transaction
11
const valueTransfer = caver.transaction.valueTransfer.create({
12
from: keyring.address,
13
to: '0x176ff0344de49c04be577a3512b6991507647f72',
14
value: 1,
15
gas: 30000,
16
})
17
18
// Sign the transaction via caver.wallet.sign
19
await caver.wallet.sign(keyring.address, valueTransfer)
20
21
const rlpEncoded = valueTransfer.getRLPEncoding()
22
console.log(`RLP-encoded string: ${rlpEncoded}`)
23
}
24
25
testFunction()
Copied!
위 코드는 Keyring을 caver.wallet에 추가하고, 트랜잭션을 생성하고, caver.wallet.sign를 통해 이 트랜잭션에 서명합니다.
위 코드를 실행하면 아래 결과를 얻습니다. 위 코드가 실행되었을 때, RLP 인코딩된 트랜잭션 문자열은 아래와 같이 나타납니다. (The RLP-encoded string output you got could be different from the string output shown below.)
1
RLP-encoded string: 0x08f87e808505d21dba0082753094176ff0344de49c04be577a3512b6991507647f720194ade4883d092e2a972d70637ca7de9ab5166894a2f847f845824e44a0e1ec99789157e5cb6bc691935c204a23aaa3dc049efafca106992a5d5db2d179a0511c421d5e508fdb335b6048ca7aa84560a53a5881d531644ff178b6aa4c0a41
Copied!

RLP 인코딩된 서명된 트랜잭션을 Klaytn에 전송합니다.

이제, 아래와 같이 서명된 트랜잭션을 Klaytn에 전송할 수 있습니다. 아래 예시를 직접 실행하려면 0x{RLP-encoded string}를 위 rlpEncoded 값으로 대체하십시오 .
1
// test.js
2
const Caver = require('caver-js')
3
const caver = new Caver('https://your.en.url:8651/')
4
5
async function testFunction() {
6
const rlpEncoding = `0x{RLP-encoded string}`
7
8
// Send the transaction using `caver.rpc.klay.sendRawTransaction`.
9
const receipt = await caver.rpc.klay.sendRawTransaction(rlpEncoding)
10
console.log(receipt)
11
}
12
13
testFunction()
Copied!
위 코드를 실행하면 아래 결과를 얻습니다. 위 코드가 실행되었을 때, 트랜잭션에 대한 영수증은 아래와 같이 나타납니다.
1
$ node ./test.js
2
{
3
blockHash: '0xd20066b448da77a41a46fbf0856792b85b60c42213126f661f6434b5b1263072',
4
blockNumber: '0x1efb',
5
contractAddress: null,
6
from: '0x09a08f2289d3eb3499868908f1c84fd9523fe11b',
7
gas: '0x7530',
8
...
9
signatures: [
10
{
11
V: '0x4e43',
12
R: '0x5737aa8c88f019a3ee184faed6d34d103f77773bd5434cb0328c11738c8d9755',
13
S: '0x578b118f4400999e5232bd0860cfbdbf89622f6e11cc6bd9722a86767d2723b7'
14
}
15
],
16
status: '0x1',
17
to: '0x176ff0344de49c04be577a3512b6991507647f72',
18
transactionHash: '0x43e8ab1a2365ad598448b4402c1cfce6a71b3a103fce3a69905613e50b978113',
19
transactionIndex: 0,
20
type: 'TxTypeValueTransfer',
21
typeInt: 8,
22
value: '0x1'
23
}
Copied!
caver.wallet 없이 트랜잭션에 서명하고 Klaytn에 서명된 트랜잭션을 보내려면 아래 예시를 확인하십시오.
1
// test.js
2
const Caver = require('caver-js')
3
const caver = new Caver('https://your.en.url:8651/')
4
5
async function testFunction() {
6
// Create a value transfer transaction
7
const keyring = caver.wallet.keyring.createFromPrivateKey('0x{private key}')
8
const valueTransfer = caver.transaction.valueTransfer.create({
9
from: keyring.address,
10
to: '0x176ff0344de49c04be577a3512b6991507647f72',
11
value: 1,
12
gas: 30000,
13
})
14
15
// Sign the transaction via transaction.sign
16
await valueTransfer.sign(keyring)
17
18
// Send the transaction to the Klaytn using `caver.rpc.klay.sendRawTransaction`.
19
const receipt = await caver.rpc.klay.sendRawTransaction(valueTransfer)
20
console.log(receipt)
21
}
22
23
testFunction()
Copied!
위 코드가 실행 되었을 때, 트랜잭션에 대한 영수증은 앞에서 소개한 예제와 같이 나타납니다.

영수증 확인

You can use the promise or event emitter to get the receipt of the transaction when you transfer the transaction to the Klaytn by caver.rpc.klay.sendRawTransaction.
다음 예시는 프로미스(promise) 및 이벤트 이미터(event emitter)를 사용하여 영수증을 받는 과정입니다.
1
// Using a promise - async/await
2
const receipt = await caver.rpc.klay.sendRawTransaction(rawTransaction)
3
console.log(receipt)
4
5
// Using a promise
6
caver.rpc.klay.sendRawTransaction(rawTransaction).then(console.log)
7
8
// Using an event emitter
9
caver.rpc.klay.sendRawTransaction(rawTransaction).on('receipt', console.log)
Copied!
위 예시와 같이 프로미스(promise)와 이벤트 이미터(event emitter)를 통해 트랜잭션을 전송한 결과를 가져올 수 있습니다. transactionHash 필드는 영수증 객체 내부에 정의됩니다. You can use caver.rpc.klay.getTransactionReceipt RPC call with receipt.transactionHash to query the receipt of a transaction at any time from the network after the transaction is included in a block. The example below shows how to get a receipt using the caver.rpc.klay.getTransactionReceipt RPC call.
1
// test.js
2
const Caver = require('caver-js')
3
const caver = new Caver('https://your.en.url:8651/')
4
5
async function testFunction() {
6
const receipt = await caver.rpc.klay.getTransactionReceipt('0x40552efbba23347d36f6f5aaba6b9aeb6602e004df62c1988d9b7b1f036e676a')
7
console.log(receipt)
8
}
9
10
testFunction()
Copied!
위 코드를 실행하면 아래 결과를 얻습니다. 위 코드가 실행되었을 때, 트랜잭션에 대한 영수증은 아래와 같이 나타납니다.
1
$ node ./test.js
2
{
3
blockHash: '0x65d041011440e04643c546eb8bbb1dcabb659c3b3216e01473cb0712e47b5f69',
4
blockNumber: '0x20db',
5
contractAddress: null,
6
from: '0x09a08f2289d3eb3499868908f1c84fd9523fe11b',
7
gas: '0x7530',
8
...
9
signatures: [
10
{
11
V: '0x4e43',
12
R: '0xfabe48071a8b72f0c340b2ee9d948a496cce467aebe027159d66a175e6b4b5b4',
13
S: '0x1d4e503f1b084cda15edeba6b7b8eba15057b9d2484f7f3d095c980c2d98f13'
14
}
15
],
16
status: '0x1',
17
to: '0x176ff0344de49c04be577a3512b6991507647f72',
18
transactionHash: '0x40552efbba23347d36f6f5aaba6b9aeb6602e004df62c1988d9b7b1f036e676a',
19
transactionIndex: 0,
20
type: 'TxTypeValueTransfer',
21
typeInt: 8,
22
value: '0x1'
23
}
Copied!
트랜잭션의 실행 결과는 영수증의 status를 통하여 확인할 수 있습니다. For the details of the return values, see caver.rpc.klay.getTransactionReceipt. 만약 트랜잭션 실행이 실패한다면 에러에 대한 자세한 내용은 영수증의 txError에서 확인할 수 있습니다. For more information about txError, see txError: Detailed Information of Transaction Failures.

다른 트랜잭션 타입 실행하기

Klaytn은 확장성과 성능을 위한 다양한 트랜잭션 타입을 제공합니다. For more information, see Transactions. 이 장에서는 caver-js와 함께 사용할 수 있는 예시를 설명합니다.

트랜잭션 수수료 위임

Klaytn provides Fee Delegation feature. 여기에서는, 여러분이 트랜잭션 전송자일 때 RLP 인코딩된 트랜잭션을 만드는 예시를 소개합니다.
1
// test.js
2
const Caver = require('caver-js')
3
const caver = new Caver('https://your.en.url:8651/')
4
5
async function testFunction() {
6
const sender = caver.wallet.keyring.createFromPrivateKey('0x{private key}')
7
caver.wallet.add(sender)
8
9
const feeDelegatedTx = caver.transaction.feeDelegatedValueTransfer.create({
10
from: sender.address,
11
to: '0x176ff0344de49c04be577a3512b6991507647f72',
12
value: 5,
13
gas: 50000,
14
})
15
16
await caver.wallet.sign(sender.address, feeDelegatedTx)
17
18
const rlpEncoded = feeDelegatedTx.getRLPEncoding()
19
console.log(rlpEncoded)
20
}
21
22
testFunction()
Copied!
위 코드가 실행되었을 때, RLP 인코딩된 문자열이 출력됩니다. (The RLP-encoded string output you got could be different from the string output shown below.)
1
$ node ./test.js
2
0x09f884028505d21dba0082c35094176ff0344de49c04be577a3512b6991507647f720594f5a9079f311f9ec55170af351627aff0c5d2e287f847f845824e43a0f4b53dbd4c915cb73b9c7fa17e22106ee9640155a06ab4a7ed8661f846d2a5cca035b5bba6a26d4ccd20c65e8f31cce265c193f1c874806f9fae6b0ee9df0addf080c4c3018080
Copied!
The fee payer can send the transaction to the Klaytn after attaching the feePayerSignatures to the RLP-encoded string (rawTransaction) signed by the transaction sender. caver.wallet에 수수료 납부자 키도 같이 있다면, caver.wallet.signAsFeePayer(feePayer.address, feeDelegatedTx)를 호출하여 수수료 납부자 서명을 feeDelegatedTx에 넣을 수 있습니다. 그렇지 않다면, 수수료 납부자는 트랜잭션 발신자가 서명한 RLP 인코딩된 문자열에서 feeDelegatedTx를 새로 만들고, 자신의 서명을 여기에 추가해야합니다. 아래 예시를 참고하십시오. 아래 예시를 직접 실행하려면 0x{RLP-encoded string}를 위 rlpEncoded 값으로 대체하십시오 .
1
// test.js
2
const Caver = require('caver-js')
3
const caver = new Caver('https://your.en.url:8651/')
4
5
async function testFunction() {
6
const feePayer = caver.wallet.keyring.createFromPrivateKey('0x{private key}')
7
caver.wallet.add(feePayer)
8
9
const rlpEncoded = '0x{RLP-encoded string}'
10
11
const feeDelegateTxFromRLPEncoding = caver.transaction.feeDelegatedValueTransfer.create(rlpEncoded)
12
13
// Set the fee payer address.
14
feeDelegateTxFromRLPEncoding.feePayer = feePayer.address
15
await caver.wallet.signAsFeePayer(feePayer.address, feeDelegateTxFromRLPEncoding)
16
17
console.log(feeDelegateTxFromRLPEncoding.getRLPEncoding())
18
}
19
20
testFunction()
Copied!
위 코드가 실행되었을 때, 발신자 서명과 수수료 납부자 서명이 첨부된 RLP 인코딩된 문자열 아래와 같이 나타납니다. (The output you got could be different from the string output shown below.)
1
$ node ./test.js
2
0x09f8dc028505d21dba0082c35094176ff0344de49c04be577a3512b6991507647f720594f5a9079f311f9ec55170af351627aff0c5d2e287f847f845824e43a0f4b53dbd4c915cb73b9c7fa17e22106ee9640155a06ab4a7ed8661f846d2a5cca035b5bba6a26d4ccd20c65e8f31cce265c193f1c874806f9fae6b0ee9df0addf09417e7531b40ad5d7b5fa7b4ec78df64ce1cb36d24f847f845824e44a0921b7c3be69db96ce14134b306c2ada423613cb66ecc6697ee8067983c268b6ea07b86b255d1c781781315d85d7904226fb2101eb9498c4a03f3fbd30ba3ec5b79
Copied!
이제 트랜잭션 발신자와 수수료 납부자 모두 트랜잭션에 서명했으니, 트랜잭션을 Klaytn에 전송할 수 있습니다. 0x{RLP-encoded string}을 위 예시 코드의 RLP 인코딩된 문자열 출력값으로 대체하십시오.
1
// test.js
2
const Caver = require('caver-js')
3
const caver = new Caver('https://your.en.url:8651/')
4
5
async function testFunction() {
6
const rlpEncoded = '0x{RLP-encoded string}'
7
const receipt = await caver.rpc.klay.sendRawTransaction(rlpEncoded)
8
console.log(receipt)
9
}
10
11
testFunction()
Copied!
위 코드를 실행하면 아래 결과를 얻습니다. 위 예시 코드 실행 결과를 보면, FeeDelegatedValueTransfer 트랜잭션 결과를 알 수 있습니다.
1
$ node ./test.js
2
{
3
blockHash: '0xb6a76163c4c558f50bdae77968a0f35dcfececf78b5cb780c3514a30a1c0a864',
4
blockNumber: '0xede',
5
contractAddress: null,
6
feePayer: '0x17e7531b40ad5d7b5fa7b4ec78df64ce1cb36d24',
7
feePayerSignatures: [
8
{
9
V: '0x4e44',
10
R: '0x921b7c3be69db96ce14134b306c2ada423613cb66ecc6697ee8067983c268b6e',
11
S: '0x7b86b255d1c781781315d85d7904226fb2101eb9498c4a03f3fbd30ba3ec5b79'
12
}
13
],
14
from: '0xf5a9079f311f9ec55170af351627aff0c5d2e287',
15
gas: '0xc350',
16
...
17
signatures: [
18
{
19
V: '0x4e43',
20
R: '0xf4b53dbd4c915cb73b9c7fa17e22106ee9640155a06ab4a7ed8661f846d2a5cc',
21
S: '0x35b5bba6a26d4ccd20c65e8f31cce265c193f1c874806f9fae6b0ee9df0addf0'
22
}
23
],
24
status: '0x1',
25
to: '0x176ff0344de49c04be577a3512b6991507647f72',
26
transactionHash: '0x1878cc27b7f259a98d3248b41bffb6158640b4a07c503095deac1913fb3856c2',
27
transactionIndex: 0,
28
type: 'TxTypeFeeDelegatedValueTransfer',
29
typeInt: 9,
30
value: '0x5'
31
}
Copied!

계정 업데이트

If you want to change the private key(s) for your Klaytn account, there are 3 important things you need to remember:
<