コンテンツにスキップ

転送トランザクションでメッセージを送信する⚓︎

中級

転送トランザクション には、最大 1024 バイトのデータをトランザクションに付加できるオプションのメッセージフィールドを含められます。 メッセージは平文で送信することも、受取人の公開鍵で暗号化することもできます。暗号化すれば、意図した受取人だけが読めます。

このチュートリアルでは、平文メッセージと暗号化メッセージの両方を送信し、受信したメッセージをデコードする方法を説明します。

前提条件⚓︎

始める前に、次の準備をしてください。

さらに、トランザクションの作成、手数料の計算、承認の仕組みを理解するため、転送トランザクション チュートリアルを確認してください。

完全なコード⚓︎

このチュートリアルの完全なコード一覧を以下に示します。 詳細な手順ごとの説明は次のセクションで行います。

  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
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
import json
import os
import time
import urllib.error
import urllib.request
from binascii import hexlify

from symbolchain.CryptoTypes import PrivateKey, PublicKey
from symbolchain.facade.NemFacade import NemFacade
from symbolchain.nc import Amount, Message, MessageType
from symbolchain.nem.FeeCalculator import calculate_transaction_fee
from symbolchain.nem.MessageEncoder import MessageEncoder

# Configuration
NODE_URL = os.getenv('NODE_URL', 'http://libertalia.nemtest.net:7890')
print(f'Using node {NODE_URL}')


# Helper function to wait for transaction confirmation
def wait_for_confirmation(tx_hash, label):
    status_path = f'/transaction/get?hash={tx_hash}'
    print(f'Waiting for {label} confirmation from {status_path}')
    is_confirmed = False
    confirmed = None
    for _ in range(120):
        try:
            with urllib.request.urlopen(
                f'{NODE_URL}{status_path}'
            ) as status_response:
                confirmed = json.loads(status_response.read().decode())
                height = confirmed['meta']['height']
                print(f'{label} confirmed in block {height}')
                is_confirmed = True
                break
        except urllib.error.HTTPError:
            print('  Transaction status: pending')
        time.sleep(1)
    if not is_confirmed:
        print(f'{label} confirmation took too long.')
    return confirmed


# Set up sender and recipient accounts
facade = NemFacade('testnet')

sender_private_key_string = os.getenv(
    'SENDER_PRIVATE_KEY',
    '0000000000000000000000000000000000000000000000000000000000000000',
)
sender_key_pair = NemFacade.KeyPair(
    PrivateKey(sender_private_key_string)
)
sender_address = facade.network.public_key_to_address(
    sender_key_pair.public_key
)

recipient_private_key_string = os.getenv(
    'RECIPIENT_PRIVATE_KEY',
    '1111111111111111111111111111111111111111111111111111111111111111',
)
recipient_key_pair = NemFacade.KeyPair(
    PrivateKey(recipient_private_key_string)
)
recipient_address = facade.network.public_key_to_address(
    recipient_key_pair.public_key
)

print(f'Sender address: {sender_address}')
print(f'Recipient address: {recipient_address}\n')

# --- PLAIN TEXT MESSAGE ---
print('==> Sending Plain Text Message')

# Create a plain text message
plain_message = 'Hello, NEM!'.encode('utf-8')
print(f'Plain message: {plain_message.decode("utf-8")}')

# Build transfer transaction with plain message
plain_transaction = facade.create_transaction_from_descriptor(
    {
        'type': 'transfer_transaction_v2',
        'recipient_address': recipient_address,
        'amount': 0,
        'message': {
            'message_type': 'plain',
            'message': plain_message,
        },
    },
    sender_key_pair.public_key,
    0,
    2 * 60 * 60
)
plain_transaction.fee = Amount(
    calculate_transaction_fee(plain_transaction))

# Sign and announce the transaction
plain_signature = facade.sign_transaction(
    sender_key_pair, plain_transaction
)
plain_json_payload = facade.transaction_factory.attach_signature(
    plain_transaction, plain_signature
)
plain_transaction_hash = facade.hash_transaction(
    plain_transaction
)
print(f'Transaction hash: {plain_transaction_hash}')

plain_announce_request = urllib.request.Request(
    f'{NODE_URL}/transaction/announce',
    data=plain_json_payload.encode('utf-8'),
    headers={'Content-Type': 'application/json'},
    method='POST',
)
with urllib.request.urlopen(plain_announce_request) as response:
    print('Plain message transaction announced\n')

# --- RECEIVING PLAIN TEXT MESSAGE ---
print('<== Receiving Plain Text Message')

# Wait for confirmation
plain_tx_data = wait_for_confirmation(
    plain_transaction_hash, 'Plain message transaction'
)

# Decode plain message from confirmed transaction
received_plain_message = bytes.fromhex(
    plain_tx_data['transaction']['message']['payload']
)
print(
    f'Received plain message: {received_plain_message.decode("utf-8")}\n'
)

# --- ENCRYPTED MESSAGE ---
print('==> Sending Encrypted Message')

# Create a message encoder with sender's key pair
sender_message_encoder = MessageEncoder(sender_key_pair)

# Encrypt the message using recipient's public key
secret_message = 'This is a secret message!'.encode('utf-8')
encrypted_message = sender_message_encoder.encode(
    recipient_key_pair.public_key, secret_message
)
print(f'Original message: {secret_message.decode("utf-8")}')
encrypted_payload = hexlify(encrypted_message.message).decode('utf-8')
print(f'Encrypted payload: {encrypted_payload}')

# Build transfer transaction with encrypted message
encrypted_transaction = facade.create_transaction_from_descriptor(
    {
        'type': 'transfer_transaction_v2',
        'recipient_address': recipient_address,
        'amount': 0,
        'message': {
            'message_type': 'encrypted',
            'message': encrypted_message.message,
        },
    },
    sender_key_pair.public_key,
    0,
    2 * 60 * 60
)
encrypted_transaction.fee = Amount(
    calculate_transaction_fee(encrypted_transaction))

# Sign and announce the transaction
encrypted_signature = facade.sign_transaction(
    sender_key_pair, encrypted_transaction
)
encrypted_json_payload = facade.transaction_factory.attach_signature(
    encrypted_transaction, encrypted_signature
)
encrypted_transaction_hash = facade.hash_transaction(
    encrypted_transaction
)
print(f'Transaction hash: {encrypted_transaction_hash}')

encrypted_announce_request = urllib.request.Request(
    f'{NODE_URL}/transaction/announce',
    data=encrypted_json_payload.encode('utf-8'),
    headers={'Content-Type': 'application/json'},
    method='POST',
)
with urllib.request.urlopen(encrypted_announce_request) as response:
    print('Encrypted message transaction announced\n')

# --- RECEIVING ENCRYPTED MESSAGE ---
print('<== Receiving Encrypted Message')

# Wait for confirmation
encrypted_tx_data = wait_for_confirmation(
    encrypted_transaction_hash, 'Encrypted message transaction'
)

# Decode encrypted message using recipient's private key
recipient_message_encoder = MessageEncoder(recipient_key_pair)
received_encrypted_message = Message()
received_encrypted_message.message_type = MessageType.ENCRYPTED
received_encrypted_message.message = bytes.fromhex(
    encrypted_tx_data['transaction']['message']['payload']
)

# Get sender's public key from the transaction
sender_public_key_from_tx = PublicKey(
    encrypted_tx_data['transaction']['signer']
)

(is_decoded, decrypted_message) = recipient_message_encoder.try_decode(
    sender_public_key_from_tx, received_encrypted_message
)

if is_decoded:
    message_text = decrypted_message.decode('utf-8')
    print(f'Recipient decrypted message: {message_text}')
else:
    print('Recipient failed to decrypt message')

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
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
import { PrivateKey, PublicKey } from 'symbol-sdk';
import {
    Address,
    MessageEncoder,
    NemFacade,
    calculateTransactionFee,
    descriptors,
    models
} from 'symbol-sdk/nem';

// Configuration
const NODE_URL = process.env.NODE_URL ||
    'http://libertalia.nemtest.net:7890';
console.log('Using node', NODE_URL);

// Helper function to wait for transaction confirmation
async function waitForConfirmation(transactionHash, label) {
    const statusPath = `/transaction/get?hash=${transactionHash}`;
    console.log(`Waiting for ${label} confirmation from`, statusPath);
    let isConfirmed = false;
    let confirmed;
    for (let attempt = 1; 120 >= attempt; ++attempt) {
        const response = await fetch(
            `${NODE_URL}${statusPath}`);
        if (!response.ok) {
            console.log('  Transaction status: pending');
            await new Promise(resolve => { setTimeout(resolve, 1000); });
        } else {
            confirmed = await response.json();
            console.log(`${label} confirmed in block`,
                confirmed.meta.height);
            isConfirmed = true;
            break;
        }
    }
    if (!isConfirmed)
        console.warn(`${label} confirmation took too long.`);
    return confirmed;
}

// Set up sender and recipient accounts
const facade = new NemFacade('testnet');

const senderPrivateKeyString = process.env.SENDER_PRIVATE_KEY ||
    '0000000000000000000000000000000000000000000000000000000000000000';
const senderKeyPair = new NemFacade.KeyPair(
    new PrivateKey(senderPrivateKeyString));
const senderAddress = facade.network.publicKeyToAddress(
    senderKeyPair.publicKey);

const recipientPrivateKeyString = process.env.RECIPIENT_PRIVATE_KEY ||
    '1111111111111111111111111111111111111111111111111111111111111111';
const recipientKeyPair = new NemFacade.KeyPair(
    new PrivateKey(recipientPrivateKeyString));
const recipientAddress = facade.network.publicKeyToAddress(
    recipientKeyPair.publicKey);

console.log('Sender address:', senderAddress.toString());
console.log('Recipient address:', recipientAddress.toString(), '\n');

// --- PLAIN TEXT MESSAGE ---
console.log('==> Sending Plain Text Message');

// Create a plain text message
const plainMessage = new TextEncoder().encode('Hello, NEM!');
console.log('Plain message:',
    new TextDecoder().decode(plainMessage));

// Build transfer transaction with plain message
const plainTransaction = facade.createTransactionFromTypedDescriptor(
    new descriptors.TransferTransactionV2Descriptor(
        new Address(recipientAddress.toString()),
        new models.Amount(0n),
        new descriptors.MessageDescriptor(
            models.MessageType.PLAIN,
            plainMessage)),
    senderKeyPair.publicKey,
    0n,
    2 * 60 * 60);
plainTransaction.fee = new models.Amount(
    calculateTransactionFee(plainTransaction));

// Sign and announce the transaction
const plainSignature = facade.signTransaction(
    senderKeyPair, plainTransaction);
const plainJsonPayload = facade.transactionFactory.static
    .attachSignature(plainTransaction, plainSignature);
const plainTransactionHash = facade.hashTransaction(
    plainTransaction).toString();
console.log('Transaction hash:', plainTransactionHash);

await fetch(`${NODE_URL}/transaction/announce`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: plainJsonPayload
});
console.log('Plain message transaction announced\n');

// --- RECEIVING PLAIN TEXT MESSAGE ---
console.log('<== Receiving Plain Text Message');

// Wait for confirmation
const plainTxData = await waitForConfirmation(
    plainTransactionHash, 'Plain message transaction');

// Decode plain message from confirmed transaction
const receivedPlainMessage = Buffer.from(
    plainTxData.transaction.message.payload, 'hex');
console.log('Received plain message:',
    new TextDecoder().decode(receivedPlainMessage), '\n');

// --- ENCRYPTED MESSAGE ---
console.log('==> Sending Encrypted Message');

// Create a message encoder with sender's key pair
const senderMessageEncoder = new MessageEncoder(senderKeyPair);

// Encrypt the message using recipient's public key
const secretMessage = new TextEncoder().encode(
    'This is a secret message!');
const encryptedMessage = senderMessageEncoder.encode(
    recipientKeyPair.publicKey, secretMessage
);
console.log('Original message:', new TextDecoder().decode(secretMessage));
console.log('Encrypted payload:',
    Buffer.from(encryptedMessage.message).toString('hex'));

// Build transfer transaction with encrypted message
const encryptedTransaction = facade.createTransactionFromTypedDescriptor(
    new descriptors.TransferTransactionV2Descriptor(
        new Address(recipientAddress.toString()),
        new models.Amount(0n),
        new descriptors.MessageDescriptor(
            models.MessageType.ENCRYPTED,
            encryptedMessage.message)),
    senderKeyPair.publicKey,
    0n,
    2 * 60 * 60);
encryptedTransaction.fee = new models.Amount(
    calculateTransactionFee(encryptedTransaction));

// Sign and announce the transaction
const encryptedSignature = facade.signTransaction(
    senderKeyPair, encryptedTransaction);
const encryptedJsonPayload = facade.transactionFactory.static
    .attachSignature(encryptedTransaction, encryptedSignature);
const encryptedTransactionHash = facade.hashTransaction(
    encryptedTransaction).toString();
console.log('Transaction hash:', encryptedTransactionHash);

await fetch(`${NODE_URL}/transaction/announce`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: encryptedJsonPayload
});
console.log('Encrypted message transaction announced\n');

// --- RECEIVING ENCRYPTED MESSAGE ---
console.log('<== Receiving Encrypted Message');

// Wait for confirmation
const encryptedTxData = await waitForConfirmation(
    encryptedTransactionHash, 'Encrypted message transaction');

// Decode encrypted message using recipient's private key
const recipientMessageEncoder = new MessageEncoder(recipientKeyPair);
const receivedEncryptedMessage = new models.Message();
receivedEncryptedMessage.messageType = models.MessageType.ENCRYPTED;
receivedEncryptedMessage.message = Buffer.from(
    encryptedTxData.transaction.message.payload, 'hex');

// Get sender's public key from the transaction
const senderPublicKeyFromTx = new PublicKey(
    encryptedTxData.transaction.signer);

const result = recipientMessageEncoder.tryDecode(
    senderPublicKeyFromTx, receivedEncryptedMessage);

if (result.isDecoded) {
    console.log('Recipient decrypted message:',
        new TextDecoder().decode(result.message));
} else {
    console.log('Recipient failed to decrypt message');
}

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
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
//JAVA 21+
//DEPS org.symbol:symbol-sdk:3.3.3

import static java.nio.charset.StandardCharsets.UTF_8;

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
import java.util.HexFormat;
import java.util.List;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

import org.symbol.sdk.CryptoTypes;
import org.symbol.sdk.MessageEncoderResult;
import org.symbol.sdk.facade.NemFacade;
import org.symbol.sdk.nem.Address;
import org.symbol.sdk.nem.FeeCalculator;
import org.symbol.sdk.nem.KeyPair;
import org.symbol.sdk.nem.MessageEncoder;
import org.symbol.sdk.nem.NemTransactionFactory;
import org.symbol.sdk.nem.descriptors.*;
import org.symbol.sdk.nem.models.Amount;
import org.symbol.sdk.nem.models.Message;
import org.symbol.sdk.nem.models.MessageType;
import org.symbol.sdk.nem.models.Transaction;

public final class Messages {
    private static final ObjectMapper JSON_MAPPER = new ObjectMapper();

    private static final HttpClient HTTP_CLIENT =
        HttpClient.newHttpClient();

    // Configuration
    private final String nodeUrl = System.getenv().getOrDefault(
        "NODE_URL", "http://libertalia.nemtest.net:7890");

    private final NemFacade facade = new NemFacade("testnet");

    private JsonNode waitForConfirmation(
        final String transactionHash,
        final String label
    ) throws IOException, InterruptedException {
        final String statusPath = String.format(
            "/transaction/get?hash=%s", transactionHash);
        System.out.printf("Waiting for %s confirmation from %s%n",
            label, statusPath);
        boolean isConfirmed = false;
        JsonNode confirmed = null;
        for (int attempt = 1; 120 >= attempt; ++attempt) {
            final HttpRequest request = HttpRequest.newBuilder(
                URI.create(nodeUrl + statusPath)).GET().build();
            final HttpResponse<String> response = HTTP_CLIENT.send(
                request, BodyHandlers.ofString());
            if (2 != response.statusCode() / 100) {
                System.out.println("  Transaction status: pending");
                Thread.sleep(1000);
            } else {
                confirmed = JSON_MAPPER.readTree(response.body());
                System.out.printf("%s confirmed in block %s%n", label,
                    confirmed.get("meta").get("height").asText());
                isConfirmed = true;
                break;
            }
        }
        if (!isConfirmed)
            System.out.printf("%s confirmation took too long.%n", label);
        return confirmed;
    }

    public static void main(final String[] args) {
        try {
            new Messages().run();
        } catch (final Exception ex) {
            System.out.println(null == ex.getMessage()
                ? ex.toString()
                : ex.getMessage());
        }
    }

    private void run() throws IOException, InterruptedException {
        System.out.printf("Using node %s%n", nodeUrl);

        // Set up sender and recipient accounts
        final String senderPrivateKeyString = System.getenv().getOrDefault(
            "SENDER_PRIVATE_KEY", "0".repeat(64));
        final KeyPair senderKeyPair = new KeyPair(
            new CryptoTypes.PrivateKey(senderPrivateKeyString));
        final Address senderAddress = facade.network.publicKeyToAddress(
            senderKeyPair.getPublicKey());

        final String recipientPrivateKeyString = System.getenv()
            .getOrDefault("RECIPIENT_PRIVATE_KEY", "1".repeat(64));
        final KeyPair recipientKeyPair = new KeyPair(
            new CryptoTypes.PrivateKey(recipientPrivateKeyString));
        final Address recipientAddress = facade.network.publicKeyToAddress(
            recipientKeyPair.getPublicKey());

        System.out.printf("Sender address: %s%n", senderAddress);
        System.out.printf("Recipient address: %s%n%n", recipientAddress);

        // --- PLAIN TEXT MESSAGE ---
        System.out.println("==> Sending Plain Text Message");

        // Create a plain text message
        final byte[] plainMessage = "Hello, NEM!".getBytes(UTF_8);
        System.out.printf("Plain message: %s%n",
            new String(plainMessage, UTF_8));

        // Build transfer transaction with plain message
        final Transaction plainTransaction =
            facade.createTransactionFromTypedDescriptor(
                new TransferTransactionV2Descriptor(
                    recipientAddress,
                    new Amount(0),
                    new MessageDescriptor(
                        MessageType.PLAIN, plainMessage),
                    List.of()),
                senderKeyPair.getPublicKey(),
                0,
                2 * 60 * 60);
        plainTransaction.setFee(new Amount(
            FeeCalculator.calculateTransactionFee(plainTransaction)));

        // Sign and announce the transaction
        final CryptoTypes.Signature plainSignature =
            facade.signTransaction(senderKeyPair, plainTransaction);
        final String plainJsonPayload = NemTransactionFactory
            .attachSignature(plainTransaction, plainSignature);
        final String plainTransactionHash = facade.hashTransaction(
            plainTransaction).toString();
        System.out.printf("Transaction hash: %s%n", plainTransactionHash);

        final HttpRequest plainRequest = HttpRequest.newBuilder(
            URI.create(nodeUrl + "/transaction/announce"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(plainJsonPayload))
            .build();
        HTTP_CLIENT.send(plainRequest, BodyHandlers.ofString());
        System.out.println("Plain message transaction announced\n");

        // --- RECEIVING PLAIN TEXT MESSAGE ---

        System.out.println("<== Receiving Plain Text Message");

        // Wait for confirmation
        final JsonNode plainTxData = waitForConfirmation(
            plainTransactionHash, "Plain message transaction");

        // Decode plain message from confirmed transaction
        final byte[] receivedPlainMessage = HexFormat.of().parseHex(
            plainTxData.get("transaction").get("message")
                .get("payload").asText());
        System.out.printf("Received plain message: %s%n%n",
            new String(receivedPlainMessage, UTF_8));

        // --- ENCRYPTED MESSAGE ---
        System.out.println("==> Sending Encrypted Message");

        // Create a message encoder with sender's key pair
        final MessageEncoder senderMessageEncoder = new MessageEncoder(
            senderKeyPair);

        // Encrypt the message using recipient's public key
        final byte[] secretMessage =
            "This is a secret message!".getBytes(UTF_8);
        final Message encryptedMessage = senderMessageEncoder.encode(
            recipientKeyPair.getPublicKey(), secretMessage
        );
        System.out.printf("Original message: %s%n",
            new String(secretMessage, UTF_8));
        System.out.printf("Encrypted payload: %s%n",
            HexFormat.of().formatHex(encryptedMessage.getMessage()));

        // Build transfer transaction with encrypted message
        final Transaction encryptedTransaction =
            facade.createTransactionFromTypedDescriptor(
                new TransferTransactionV2Descriptor(
                    recipientAddress,
                    new Amount(0),
                    new MessageDescriptor(
                        MessageType.ENCRYPTED,
                        encryptedMessage.getMessage()),
                    List.of()),
                senderKeyPair.getPublicKey(),
                0,
                2 * 60 * 60);
        encryptedTransaction.setFee(new Amount(
            FeeCalculator.calculateTransactionFee(encryptedTransaction)));

        // Sign and announce the transaction
        final CryptoTypes.Signature encryptedSignature =
            facade.signTransaction(senderKeyPair, encryptedTransaction);
        final String encryptedJsonPayload = NemTransactionFactory
            .attachSignature(encryptedTransaction, encryptedSignature);
        final String encryptedTransactionHash = facade.hashTransaction(
            encryptedTransaction).toString();
        System.out.printf("Transaction hash: %s%n",
            encryptedTransactionHash);

        final HttpRequest encryptedRequest = HttpRequest.newBuilder(
            URI.create(nodeUrl + "/transaction/announce"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(
                encryptedJsonPayload))
            .build();
        HTTP_CLIENT.send(encryptedRequest, BodyHandlers.ofString());
        System.out.println("Encrypted message transaction announced\n");

        // --- RECEIVING ENCRYPTED MESSAGE ---
        System.out.println("<== Receiving Encrypted Message");

        // Wait for confirmation
        final JsonNode encryptedTxData = waitForConfirmation(
            encryptedTransactionHash, "Encrypted message transaction");

        // Decode encrypted message using recipient's private key
        final MessageEncoder recipientMessageEncoder = new MessageEncoder(
            recipientKeyPair);
        final Message receivedEncryptedMessage = new Message();
        receivedEncryptedMessage.setMessageType(MessageType.ENCRYPTED);
        receivedEncryptedMessage.setMessage(HexFormat.of().parseHex(
            encryptedTxData.get("transaction").get("message")
                .get("payload").asText()));

        // Get sender's public key from the transaction
        final CryptoTypes.PublicKey senderPublicKeyFromTx =
            new CryptoTypes.PublicKey(encryptedTxData.get("transaction")
                .get("signer").asText());

        final MessageEncoderResult result =
            recipientMessageEncoder.tryDecode(
                senderPublicKeyFromTx, receivedEncryptedMessage);

        if (result.isDecoded()) {
            System.out.printf("Recipient decrypted message: %s%n",
                new String((byte[]) result.message(), UTF_8));
        } else {
            System.out.println("Recipient failed to decrypt message");
        }
    }
}

Download source

コードの説明⚓︎

このチュートリアルでは、転送トランザクションのメッセージ固有の部分に焦点を当てます。 手数料の計算とトランザクションのアナウンスについては 転送トランザクション チュートリアルで説明しているため、ここでは省略します。

アカウントをセットアップする⚓︎

43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
# Set up sender and recipient accounts
facade = NemFacade('testnet')

sender_private_key_string = os.getenv(
    'SENDER_PRIVATE_KEY',
    '0000000000000000000000000000000000000000000000000000000000000000',
)
sender_key_pair = NemFacade.KeyPair(
    PrivateKey(sender_private_key_string)
)
sender_address = facade.network.public_key_to_address(
    sender_key_pair.public_key
)

recipient_private_key_string = os.getenv(
    'RECIPIENT_PRIVATE_KEY',
    '1111111111111111111111111111111111111111111111111111111111111111',
)
recipient_key_pair = NemFacade.KeyPair(
    PrivateKey(recipient_private_key_string)
)
recipient_address = facade.network.public_key_to_address(
    recipient_key_pair.public_key
)

print(f'Sender address: {sender_address}')
print(f'Recipient address: {recipient_address}\n')

41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
// Set up sender and recipient accounts
const facade = new NemFacade('testnet');

const senderPrivateKeyString = process.env.SENDER_PRIVATE_KEY ||
    '0000000000000000000000000000000000000000000000000000000000000000';
const senderKeyPair = new NemFacade.KeyPair(
    new PrivateKey(senderPrivateKeyString));
const senderAddress = facade.network.publicKeyToAddress(
    senderKeyPair.publicKey);

const recipientPrivateKeyString = process.env.RECIPIENT_PRIVATE_KEY ||
    '1111111111111111111111111111111111111111111111111111111111111111';
const recipientKeyPair = new NemFacade.KeyPair(
    new PrivateKey(recipientPrivateKeyString));
const recipientAddress = facade.network.publicKeyToAddress(
    recipientKeyPair.publicKey);

console.log('Sender address:', senderAddress.toString());
console.log('Recipient address:', recipientAddress.toString(), '\n');

 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
        // Set up sender and recipient accounts
        final String senderPrivateKeyString = System.getenv().getOrDefault(
            "SENDER_PRIVATE_KEY", "0".repeat(64));
        final KeyPair senderKeyPair = new KeyPair(
            new CryptoTypes.PrivateKey(senderPrivateKeyString));
        final Address senderAddress = facade.network.publicKeyToAddress(
            senderKeyPair.getPublicKey());

        final String recipientPrivateKeyString = System.getenv()
            .getOrDefault("RECIPIENT_PRIVATE_KEY", "1".repeat(64));
        final KeyPair recipientKeyPair = new KeyPair(
            new CryptoTypes.PrivateKey(recipientPrivateKeyString));
        final Address recipientAddress = facade.network.publicKeyToAddress(
            recipientKeyPair.getPublicKey());

        System.out.printf("Sender address: %s%n", senderAddress);
        System.out.printf("Recipient address: %s%n%n", recipientAddress);

メッセージを送信するには、送信者の 秘密鍵 と受取人の アドレス が必要です。 メッセージを暗号化するには、さらに受取人の 公開鍵 が必要です。

このチュートリアルでは、平文メッセージと暗号化メッセージの送受信を示すため、送信者と受取人の 2 つのアカウントを使います。 スニペットは、SENDER_PRIVATE_KEY と RECIPIENT_PRIVATE_KEY 環境変数からそれぞれの秘密鍵を読み込み、設定されていない場合はテスト用キーをデフォルト値として使用します。 受取人の公開鍵とアドレスは、秘密鍵から導出されます。

公開鍵を取得する

アドレスだけがわかっている場合は、/account/get GET エンドポイントを使ってネットワークから公開鍵を取得できます。 アカウントの公開鍵が利用可能になるのは、少なくとも 1 回トランザクションを送信した後です。

平文メッセージを送信する⚓︎

72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
print('==> Sending Plain Text Message')

# Create a plain text message
plain_message = 'Hello, NEM!'.encode('utf-8')
print(f'Plain message: {plain_message.decode("utf-8")}')

# Build transfer transaction with plain message
plain_transaction = facade.create_transaction_from_descriptor(
    {
        'type': 'transfer_transaction_v2',
        'recipient_address': recipient_address,
        'amount': 0,
        'message': {
            'message_type': 'plain',
            'message': plain_message,
        },
    },
    sender_key_pair.public_key,
    0,
    2 * 60 * 60
)

62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
console.log('==> Sending Plain Text Message');

// Create a plain text message
const plainMessage = new TextEncoder().encode('Hello, NEM!');
console.log('Plain message:',
    new TextDecoder().decode(plainMessage));

// Build transfer transaction with plain message
const plainTransaction = facade.createTransactionFromTypedDescriptor(
    new descriptors.TransferTransactionV2Descriptor(
        new Address(recipientAddress.toString()),
        new models.Amount(0n),
        new descriptors.MessageDescriptor(
            models.MessageType.PLAIN,
            plainMessage)),
    senderKeyPair.publicKey,
    0n,
    2 * 60 * 60);

107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
        System.out.println("==> Sending Plain Text Message");

        // Create a plain text message
        final byte[] plainMessage = "Hello, NEM!".getBytes(UTF_8);
        System.out.printf("Plain message: %s%n",
            new String(plainMessage, UTF_8));

        // Build transfer transaction with plain message
        final Transaction plainTransaction =
            facade.createTransactionFromTypedDescriptor(
                new TransferTransactionV2Descriptor(
                    recipientAddress,
                    new Amount(0),
                    new MessageDescriptor(
                        MessageType.PLAIN, plainMessage),
                    List.of()),
                senderKeyPair.getPublicKey(),
                0,
                2 * 60 * 60);

トランザクションディスクリプタに mosaics フィールドと message フィールドの両方を含めることで、モザイクの転送とメッセージを組み合わせられます。 ファサードは署名者を追加し、2 時間のデッドライン期間からタイムスタンプとデッドラインを導出します。

その後、転送トランザクションで XEM を送信する と同じ手順でトランザクションに署名してアナウンスします。

メッセージの制約:

  • 最大サイズ: 1024 バイト（ネットワークはそれより大きいメッセージを拒否します）。
  • エンコーディング: 慣例では UTF-8 ですが、プロトコルは標準を強制しません。
  • プライバシー: 暗号化しない限り、すべてのメッセージはブロックチェーン上で公開されます。

大きなデータを扱う

1024 バイトを超えるデータが必要なアプリケーションでは、一般的に次の方法を使います。

  • オンチェーンストレージ: データを複数の 転送トランザクション に分割して、すべてをブロックチェーン上に保持する。
  • オフチェーンストレージ: データをオフチェーンに保存し、メッセージフィールドにハッシュと参照を含める。 ハッシュでデータの完全性を検証し、参照で取得できるようにします。

平文メッセージを受信する⚓︎

118
119
120
121
122
123
124
125
126
127
128
129
130
131
print('<== Receiving Plain Text Message')

# Wait for confirmation
plain_tx_data = wait_for_confirmation(
    plain_transaction_hash, 'Plain message transaction'
)

# Decode plain message from confirmed transaction
received_plain_message = bytes.fromhex(
    plain_tx_data['transaction']['message']['payload']
)
print(
    f'Received plain message: {received_plain_message.decode("utf-8")}\n'
)

100
101
102
103
104
105
106
107
108
109
110
console.log('<== Receiving Plain Text Message');

// Wait for confirmation
const plainTxData = await waitForConfirmation(
    plainTransactionHash, 'Plain message transaction');

// Decode plain message from confirmed transaction
const receivedPlainMessage = Buffer.from(
    plainTxData.transaction.message.payload, 'hex');
console.log('Received plain message:',
    new TextDecoder().decode(receivedPlainMessage), '\n');

148
149
150
151
152
153
154
155
156
157
158
159
        System.out.println("<== Receiving Plain Text Message");

        // Wait for confirmation
        final JsonNode plainTxData = waitForConfirmation(
            plainTransactionHash, "Plain message transaction");

        // Decode plain message from confirmed transaction
        final byte[] receivedPlainMessage = HexFormat.of().parseHex(
            plainTxData.get("transaction").get("message")
                .get("payload").asText());
        System.out.printf("Received plain message: %s%n%n",
            new String(receivedPlainMessage, UTF_8));

トランザクションをアナウンスした後、 ヘルパー関数はトランザクションが承認されるまで /transaction/get GET エンドポイントをポーリングします。

承認されたトランザクションには、メッセージが 16 進数文字列で含まれています。 元のメッセージを取得するには、16 進数文字列をバイト列に変換し、UTF-8 としてデコードします。

暗号化メッセージを送信する⚓︎

134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
print('==> Sending Encrypted Message')

# Create a message encoder with sender's key pair
sender_message_encoder = MessageEncoder(sender_key_pair)

# Encrypt the message using recipient's public key
secret_message = 'This is a secret message!'.encode('utf-8')
encrypted_message = sender_message_encoder.encode(
    recipient_key_pair.public_key, secret_message
)
print(f'Original message: {secret_message.decode("utf-8")}')
encrypted_payload = hexlify(encrypted_message.message).decode('utf-8')
print(f'Encrypted payload: {encrypted_payload}')

# Build transfer transaction with encrypted message
encrypted_transaction = facade.create_transaction_from_descriptor(
    {
        'type': 'transfer_transaction_v2',
        'recipient_address': recipient_address,
        'amount': 0,
        'message': {
            'message_type': 'encrypted',
            'message': encrypted_message.message,
        },
    },
    sender_key_pair.public_key,
    0,
    2 * 60 * 60
)

113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
console.log('==> Sending Encrypted Message');

// Create a message encoder with sender's key pair
const senderMessageEncoder = new MessageEncoder(senderKeyPair);

// Encrypt the message using recipient's public key
const secretMessage = new TextEncoder().encode(
    'This is a secret message!');
const encryptedMessage = senderMessageEncoder.encode(
    recipientKeyPair.publicKey, secretMessage
);
console.log('Original message:', new TextDecoder().decode(secretMessage));
console.log('Encrypted payload:',
    Buffer.from(encryptedMessage.message).toString('hex'));

// Build transfer transaction with encrypted message
const encryptedTransaction = facade.createTransactionFromTypedDescriptor(
    new descriptors.TransferTransactionV2Descriptor(
        new Address(recipientAddress.toString()),
        new models.Amount(0n),
        new descriptors.MessageDescriptor(
            models.MessageType.ENCRYPTED,
            encryptedMessage.message)),
    senderKeyPair.publicKey,
    0n,
    2 * 60 * 60);

162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
        System.out.println("==> Sending Encrypted Message");

        // Create a message encoder with sender's key pair
        final MessageEncoder senderMessageEncoder = new MessageEncoder(
            senderKeyPair);

        // Encrypt the message using recipient's public key
        final byte[] secretMessage =
            "This is a secret message!".getBytes(UTF_8);
        final Message encryptedMessage = senderMessageEncoder.encode(
            recipientKeyPair.getPublicKey(), secretMessage
        );
        System.out.printf("Original message: %s%n",
            new String(secretMessage, UTF_8));
        System.out.printf("Encrypted payload: %s%n",
            HexFormat.of().formatHex(encryptedMessage.getMessage()));

        // Build transfer transaction with encrypted message
        final Transaction encryptedTransaction =
            facade.createTransactionFromTypedDescriptor(
                new TransferTransactionV2Descriptor(
                    recipientAddress,
                    new Amount(0),
                    new MessageDescriptor(
                        MessageType.ENCRYPTED,
                        encryptedMessage.getMessage()),
                    List.of()),
                senderKeyPair.getPublicKey(),
                0,
                2 * 60 * 60);

暗号化メッセージは、送信者の秘密鍵と受取人の公開鍵から導出した共有秘密を使ってメッセージの内容を保護し、機密性を提供します。 送信者と受取人は、自分の秘密鍵と相手の公開鍵を使ってメッセージを復号できます。

クラスがメッセージの暗号化を処理します。

  1. 送信者のキーペアで を作成する。
  2. 受取人の公開鍵とメッセージバイトを使い、 でメッセージをエンコードする。
  3. 暗号化したペイロードをトランザクションの message フィールドに付加する。

その後、転送トランザクションで XEM を送信する と同じ手順でトランザクションに署名してアナウンスします。

メッセージの暗号化は慣例です

NEM プロトコルは、メッセージ暗号化の標準を定義していません。 送信者と受取人は、メッセージを暗号化するかどうか、および使用する暗号方式について事前に合意する必要があります。

は AES-GCM を実装します。これは、ほとんどのウォレットとアプリケーションが使用する慣例です。 このクラスには、初期の NEM ウォレットとアプリケーションが使用した従来の AES-CBC メッセージと互換性を保つため、 もあります。 は両方の方式を自動的に検出してデコードします。

詳細については、テキストブックの オプションメッセージ を参照してください。

暗号化メッセージを受信する⚓︎

188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
print('<== Receiving Encrypted Message')

# Wait for confirmation
encrypted_tx_data = wait_for_confirmation(
    encrypted_transaction_hash, 'Encrypted message transaction'
)

# Decode encrypted message using recipient's private key
recipient_message_encoder = MessageEncoder(recipient_key_pair)
received_encrypted_message = Message()
received_encrypted_message.message_type = MessageType.ENCRYPTED
received_encrypted_message.message = bytes.fromhex(
    encrypted_tx_data['transaction']['message']['payload']
)

# Get sender's public key from the transaction
sender_public_key_from_tx = PublicKey(
    encrypted_tx_data['transaction']['signer']
)

(is_decoded, decrypted_message) = recipient_message_encoder.try_decode(
    sender_public_key_from_tx, received_encrypted_message
)

if is_decoded:
    message_text = decrypted_message.decode('utf-8')
    print(f'Recipient decrypted message: {message_text}')
else:
    print('Recipient failed to decrypt message')

159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
console.log('<== Receiving Encrypted Message');

// Wait for confirmation
const encryptedTxData = await waitForConfirmation(
    encryptedTransactionHash, 'Encrypted message transaction');

// Decode encrypted message using recipient's private key
const recipientMessageEncoder = new MessageEncoder(recipientKeyPair);
const receivedEncryptedMessage = new models.Message();
receivedEncryptedMessage.messageType = models.MessageType.ENCRYPTED;
receivedEncryptedMessage.message = Buffer.from(
    encryptedTxData.transaction.message.payload, 'hex');

// Get sender's public key from the transaction
const senderPublicKeyFromTx = new PublicKey(
    encryptedTxData.transaction.signer);

const result = recipientMessageEncoder.tryDecode(
    senderPublicKeyFromTx, receivedEncryptedMessage);

if (result.isDecoded) {
    console.log('Recipient decrypted message:',
        new TextDecoder().decode(result.message));
} else {
    console.log('Recipient failed to decrypt message');
}

215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
        System.out.println("<== Receiving Encrypted Message");

        // Wait for confirmation
        final JsonNode encryptedTxData = waitForConfirmation(
            encryptedTransactionHash, "Encrypted message transaction");

        // Decode encrypted message using recipient's private key
        final MessageEncoder recipientMessageEncoder = new MessageEncoder(
            recipientKeyPair);
        final Message receivedEncryptedMessage = new Message();
        receivedEncryptedMessage.setMessageType(MessageType.ENCRYPTED);
        receivedEncryptedMessage.setMessage(HexFormat.of().parseHex(
            encryptedTxData.get("transaction").get("message")
                .get("payload").asText()));

        // Get sender's public key from the transaction
        final CryptoTypes.PublicKey senderPublicKeyFromTx =
            new CryptoTypes.PublicKey(encryptedTxData.get("transaction")
                .get("signer").asText());

        final MessageEncoderResult result =
            recipientMessageEncoder.tryDecode(
                senderPublicKeyFromTx, receivedEncryptedMessage);

        if (result.isDecoded()) {
            System.out.printf("Recipient decrypted message: %s%n",
                new String((byte[]) result.message(), UTF_8));
        } else {
            System.out.println("Recipient failed to decrypt message");
        }

暗号化メッセージのトランザクションをアナウンスした後、 ヘルパー関数は承認を待ちます。

承認されたトランザクションのメッセージを復号するには、受取人のキーペアで を作成し、送信者の公開鍵（トランザクションの signer フィールドから取得）と暗号化ペイロードを指定して を呼び出します。

メソッドは、復号に成功したかどうかを示す タプルを返します。成功した場合は元の平文バイトが含まれ、さらにデコードする必要があります。

復号はどちらの方向でも機能します

暗号化では両方のキーペアから導出した共有秘密を使うため、送信者も自分の秘密鍵と受取人の公開鍵でメッセージを復号できます。 これにより、ブロックチェーン上に公開された後で、双方がメッセージの内容を検証できます。

復号に失敗する原因には、次のものがあります。

  • メッセージが別の受取人向けに暗号化されている。
  • メッセージが破損している、または改ざんされている。
  • メッセージが暗号化されておらず、平文である。
  • 相手に対して誤った公開鍵を使った。
  • 暗号化と復号で同じ慣例を使っていない。

出力⚓︎

以下は、プログラムの実行時の出力例です。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Using node http://libertalia.nemtest.net:7890
Sender address: TBONKWCOWBZYZB2I5JD3LSDBQVBYHB757VN3SKPP
Recipient address: TBULEAUG2CZQISUR442HWA6UAKGWIXHDABJVIPS4

==> Sending Plain Text Message
Plain message: Hello, NEM!
Transaction hash: 2F8F20CAF8F6FA42ADE05ED85FED0B4D1DA88051972405C4AE2D181B01FB69C3
Plain message transaction announced

<== Receiving Plain Text Message
Polling for Plain message transaction confirmation...
  Plain message transaction confirmed!
Received plain message: Hello, NEM!

==> Sending Encrypted Message
Original message: This is a secret message!
Encrypted payload: 3fefcf6e4f1e5e2165f941a5c15ea66778f82eded50cfbde5fc27eba24f4580ff72fb9d0b45061747be0324a120dc357dd11351c09
Transaction hash: 76604471D5A345E6F5CE20C65D618BC6F9A600F1DF515A696B2152E0E2D0B427
Encrypted message transaction announced

<== Receiving Encrypted Message
Polling for Encrypted message transaction confirmation...
  Encrypted message transaction confirmed!
Recipient decrypted message: This is a secret message!

出力の要点は次のとおりです。

  • 平文メッセージ（6 行目）: 1 つ目のトランザクションに付加されたメッセージ。暗号化されていないため、ブロックチェーンを調べる人は誰でも読めます。
  • 受信した平文メッセージ（13 行目）: 16 進数ペイロードを UTF-8 に戻し、承認されたトランザクションから復元した同じメッセージ。
  • 元のメッセージ（16 行目）: 暗号化前の秘密メッセージ。
  • 暗号化ペイロード（17 行目）: で前のメッセージを暗号化した結果で、16 進数文字列として表示されます。これがブロックチェーンに保存される内容です。
  • 受取人が復号したメッセージ（24 行目）: 承認されたトランザクションから取得し、受取人の秘密鍵と送信者の公開鍵を使って で復号した元のメッセージ。

出力に表示されたトランザクションハッシュを NEM テストネットエクスプローラー で検索すれば、トランザクションを確認できます。 エクスプローラーは秘密鍵にアクセスできないため、暗号化メッセージを復号できません。

まとめ⚓︎

このチュートリアルでは、次の方法を説明しました。

手順 関連ドキュメント
テキストを UTF-8 バイトに変換する TextEncoder（JS）と str.encode/bytes.decode（Python）
SDK の一部ではないシステムメソッド
メッセージを暗号化する
メッセージを復号する