Skip to content

Creating Accounts from Private Keys⚓︎

This tutorial shows how to create accounts for the Symbol blockchain, either by using an existing private key or by generating a new random account.

Prerequisites⚓︎

If you have not done so already, start with Setting Up a Development Environment.

Full Code⚓︎

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import os
from symbolchain.CryptoTypes import PrivateKey
from symbolchain.facade.SymbolFacade import SymbolFacade

# Initialize the facade for the testnet network
facade = SymbolFacade('testnet')

# Use an existing private key if provided,
# Otherwise generate a random one.
private_key_string = os.environ.get('PRIVATE_KEY')
if private_key_string:
    print("Loading account from environment variable...")
    private_key = PrivateKey(private_key_string)
else:
    print("Generating random account...")
    private_key = PrivateKey.random()

# Create a key pair from the private key
key_pair = facade.KeyPair(private_key)

# Derive the public key from the private key
public_key = key_pair.public_key

# Derive the address from the public key
address = facade.network.public_key_to_address(public_key)

# Output the account details
print(f'Address: {address}')
print(f'Public key: {public_key}')
print(f'Private key: {private_key}')

Download source

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import { PrivateKey } from 'symbol-sdk';
import { SymbolFacade } from 'symbol-sdk/symbol';
import process from 'process';

// Initialize the facade for the testnet network
const facade = new SymbolFacade('testnet');

// Use an existing private key if provided,
// Otherwise generate a random one.
const privateKeyString = process.env.PRIVATE_KEY;
let privateKey;
if (privateKeyString) {
    console.log('Loading account from environment variable...');
    privateKey = new PrivateKey(privateKeyString);
} else {
    console.log('Generating random account...');
    privateKey = PrivateKey.random();
}

// Create a key pair from the private key
const keyPair = new SymbolFacade.KeyPair(privateKey);

// Derive the public key from the private key
const publicKey = keyPair.publicKey;

// Derive the address from the public key
const address = facade.network.publicKeyToAddress(publicKey);

// Output the account details
console.log('Address:', address.toString());
console.log('Public key:', publicKey.toString());
console.log('Private key:', privateKey.toString());

Download source

Code Explanation⚓︎

Initializing the Facade⚓︎

5
6
# Initialize the facade for the testnet network
facade = SymbolFacade('testnet')

5
6
// Initialize the facade for the testnet network
const facade = new SymbolFacade('testnet');

The provides access to Symbol’s cryptographic operations and network utilities. It is initialized with a network name (testnet or mainnet) to ensure that network-specific values, such as addresses, are generated correctly.

Defining a Private Key⚓︎

 8
 9
10
11
12
13
14
15
16
# Use an existing private key if provided,
# Otherwise generate a random one.
private_key_string = os.environ.get('PRIVATE_KEY')
if private_key_string:
    print("Loading account from environment variable...")
    private_key = PrivateKey(private_key_string)
else:
    print("Generating random account...")
    private_key = PrivateKey.random()

 8
 9
10
11
12
13
14
15
16
17
// Use an existing private key if provided,
// Otherwise generate a random one.
const privateKeyString = process.env.PRIVATE_KEY;
let privateKey;
if (privateKeyString) {
    console.log('Loading account from environment variable...');
    privateKey = new PrivateKey(privateKeyString);
} else {
    console.log('Generating random account...');
    privateKey = PrivateKey.random();

The example starts by retrieving a private key from the environment variable PRIVATE_KEY as a hexadecimal string. If the variable is set, the value is converted into a object. Otherwise, a new random private key is generated using instead.

Store your private key securely

The private key gives full control over the account and any assets it holds. If you lose the private key, you lose access to the account permanently. If someone else obtains the private key, they can control the account.

Never share your private key with anyone, and always store it in a secure location.

Creating the Account⚓︎

18
19
20
21
22
23
24
25
26
27
28
29
30
# Create a key pair from the private key
key_pair = facade.KeyPair(private_key)

# Derive the public key from the private key
public_key = key_pair.public_key

# Derive the address from the public key
address = facade.network.public_key_to_address(public_key)

# Output the account details
print(f'Address: {address}')
print(f'Public key: {public_key}')
print(f'Private key: {private_key}')

19
20
21
22
23
24
25
26
27
28
29
30
31
// Create a key pair from the private key
const keyPair = new SymbolFacade.KeyPair(privateKey);

// Derive the public key from the private key
const publicKey = keyPair.publicKey;

// Derive the address from the public key
const address = facade.network.publicKeyToAddress(publicKey);

// Output the account details
console.log('Address:', address.toString());
console.log('Public key:', publicKey.toString());
console.log('Private key:', privateKey.toString());

After defining the private key, an account is created by deriving its public key and address.

  1. Key pair creation: The constructor takes the private key and mathematically derives the corresponding public key. While the private key must remain secret, the public key can be safely shared with anyone.

  2. Address derivation: The method converts the public key into an address, a shorter, human-readable, network-specific identifier for the account.

Output⚓︎

The output shown below corresponds to a typical run of the program.

Loading account from environment variable...
Address: TCHBDENCLKEBILBPWP3JPB2XNY64OE7PYHHE32I
Public key: 3B6A27BCCEB6A42D62A3A8D02A6F0D73653215771DE243A63AC048A18B59DA29
Private key: 0000000000000000000000000000000000000000000000000000000000000000

Each time the program runs without the environment variable, it generates a different random account. If a private key is provided, the same public key and address are always derived.

Conclusion⚓︎

This tutorial showed how to:

Step Related documentation
Load a private key
Create a random private key
Get the public key
Get the address

Next Steps⚓︎

Now that you have an account, you can: