中級

マルチシグアカウントからのトランザクション署名⚓︎

このチュートリアルでは、転送トランザクションの作成チュートリアルと同様に、アカウントから自身へ 1 XYM を転送します。

ただし、このケースでは送信元がマルチシグアカウント（「マルチシグ」とも呼ばれます）であるため、アカウント単体でトランザクションを開始したり署名したりすることはできません。代わりに、連署者アカウントのいずれかがトランザクションを作成し、代理で署名を行います。

このチュートリアルでは、マルチシグアカウントの設定チュートリアルで作成したマルチシグ構成を使用し、連署者 0 がトランザクションの開始と署名を行います。

前提条件⚓︎

開始する前に、以下を確認してください。

開発環境をセットアップしていること。開発環境のセットアップを参照してください。
マルチシグアカウントの設定チュートリアルを完了していること。

さらに、トランザクションがどのようにアナウンスされ承認されるかを理解するために転送トランザクションチュートリアルを、アグリゲートトランザクションの仕組みを理解するためにアグリゲートコンプリートトランザクションのチュートリアルを復習しておいてください。

完全なコード⚓︎

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

Python JavaScript

import json
import os
import time
import urllib.request

from symbolchain.CryptoTypes import PrivateKey
from symbolchain.facade.SymbolFacade import SymbolFacade
from symbolchain.sc import Amount
from symbolchain.symbol.Network import NetworkTimestamp
from symbolchain.symbol.IdGenerator import generate_mosaic_alias_id

NODE_URL = 'https://reference.symboltest.net:3001'
print(f'Using node {NODE_URL}')


MULTISIG_PRIVATE_KEY = os.getenv(
    'MULTISIG_PRIVATE_KEY',
    '0000000000000000000000000000000000000000000000000000000000000001')
multisig_key_pair = SymbolFacade.KeyPair(
    PrivateKey(MULTISIG_PRIVATE_KEY))
print(f'Multisig public key: {multisig_key_pair.public_key}')
COSIGNATORY0_PRIVATE_KEY = os.getenv(
    'COSIGNATORY0_PRIVATE_KEY',
    '0000000000000000000000000000000000000000000000000000000000000002')
cosignatory_key_pair = SymbolFacade.KeyPair(
    PrivateKey(COSIGNATORY0_PRIVATE_KEY))
print(f'Cosignatory public key: {cosignatory_key_pair.public_key}')

facade = SymbolFacade('testnet')

try:
    # Fetch current network time
    time_path = '/node/time'
    print(f'Fetching current network time from {time_path}')
    with urllib.request.urlopen(f'{NODE_URL}{time_path}') as response:
        response_json = json.loads(response.read().decode())
        timestamp = NetworkTimestamp(int(
            response_json['communicationTimestamps']['receiveTimestamp']))
        print(f'  Network time: {timestamp.timestamp} ms since nemesis')

    # Fetch recommended fees
    fee_path = '/network/fees/transaction'
    print(f'Fetching recommended fees from {fee_path}')
    with urllib.request.urlopen(f'{NODE_URL}{fee_path}') as response:
        response_json = json.loads(response.read().decode())
        median_mult = response_json['medianFeeMultiplier']
        minimum_mult = response_json['minFeeMultiplier']
        fee_mult = max(median_mult, minimum_mult)
        print(f'  Fee multiplier: {fee_mult}')

    # Build the embedded transfer transaction
    transfer_transaction = facade.transaction_factory.create_embedded({
        'type': 'transfer_transaction_v1',
        'signer_public_key': multisig_key_pair.public_key,
        'recipient_address':
            facade.network.public_key_to_address(
                multisig_key_pair.public_key),
        'mosaics': [{
            'mosaic_id': generate_mosaic_alias_id('symbol.xym'),
            'amount': 1_000_000 # 1 XYM
        }]
    })

    # Build the wrapper aggregate transaction
    transaction = facade.transaction_factory.create({
        'type': 'aggregate_complete_transaction_v3',
        # This is the account that will pay for the transaction
        'signer_public_key': cosignatory_key_pair.public_key,
        'deadline': timestamp.add_hours(2).timestamp,
        'transactions_hash': facade.hash_embedded_transactions(
            [transfer_transaction]),
        'transactions': [transfer_transaction]
    })
    transaction.fee = Amount(fee_mult * transaction.size)

    # Sign the aggregate transaction using the cosignatory's signature
    json_payload = facade.transaction_factory.attach_signature(
        transaction,
        facade.sign_transaction(cosignatory_key_pair, transaction))
    print('Built transaction:')
    print(json.dumps(transaction.to_json(), indent=2))

    # Announce the transaction
    announce_path = '/transactions'
    print(f'Announcing transaction to {announce_path}')
    announce_request = urllib.request.Request(
        f'{NODE_URL}{announce_path}',
        data=json_payload.encode(),
        headers={ 'Content-Type': 'application/json' },
        method='PUT'
    )
    with urllib.request.urlopen(announce_request) as response:
        print(f'  Response: {response.read().decode()}')

    # Wait for confirmation
    status_path = (
        f'/transactionStatus/{facade.hash_transaction(transaction)}')
    print(f'Waiting for confirmation from {status_path}')
    for attempt in range(60):
        time.sleep(1)
        try:
            with urllib.request.urlopen(
                f'{NODE_URL}{status_path}'
            ) as response:
                status = json.loads(response.read().decode())
                print(f'  Transaction status: {status['group']}')
                if status['group'] == 'confirmed':
                    print(f'Transaction confirmed in {attempt} seconds')
                    break
                if status['group'] == 'failed':
                    print(f'Transaction failed: {status['code']}')
                    break
        except urllib.error.HTTPError as e:
            print(f'  Transaction status: unknown | Cause: ({e.msg})')
    else:
        print('Confirmation took too long.')

except urllib.error.URLError as e:
    print(e.reason)

Download source

import { PrivateKey } from 'symbol-sdk';
import {
    SymbolFacade,
    NetworkTimestamp,
    models,
    generateMosaicAliasId
} from 'symbol-sdk/symbol';

const NODE_URL = 'https://reference.symboltest.net:3001';
console.log('Using node', NODE_URL);

const MULTISIG_PRIVATE_KEY = process.env.MULTISIG_PRIVATE_KEY || (
    '0000000000000000000000000000000000000000000000000000000000000001');
const multisigKeyPair = new SymbolFacade.KeyPair(
    new PrivateKey(MULTISIG_PRIVATE_KEY));
console.log(`Multisig public key: ${multisigKeyPair.publicKey}`);
const COSIGNATORY0_PRIVATE_KEY = process.env.COSIGNATORY0_PRIVATE_KEY || (
    '0000000000000000000000000000000000000000000000000000000000000002');
const cosignatoryKeyPair = new SymbolFacade.KeyPair(
    new PrivateKey(COSIGNATORY0_PRIVATE_KEY));
console.log(`Cosignatory public key: ${cosignatoryKeyPair.publicKey}`);

const facade = new SymbolFacade('testnet');

try {
    // Fetch current network time
    const timePath = '/node/time';
    console.log('Fetching current network time from', timePath);
    const timeResponse = await fetch(`${NODE_URL}${timePath}`);
    const timeJSON = await timeResponse.json();
    const timestamp = new NetworkTimestamp(
        timeJSON.communicationTimestamps.receiveTimestamp);
    console.log('  Network time:', timestamp.timestamp,
        'ms since nemesis');

    // Fetch recommended fees
    const feePath = '/network/fees/transaction';
    console.log('Fetching recommended fees from', feePath);
    const feeResponse = await fetch(`${NODE_URL}${feePath}`);
    const feeJSON = await feeResponse.json();
    const medianMult = feeJSON.medianFeeMultiplier;
    const minimumMult = feeJSON.minFeeMultiplier;
    const feeMult = Math.max(medianMult, minimumMult);
    console.log('  Fee multiplier:', feeMult);

    // Build the embedded transfer transaction
    const transferTransaction = facade.transactionFactory.createEmbedded({
        type: 'transfer_transaction_v1',
        signerPublicKey: multisigKeyPair.publicKey.toString(),
        recipientAddress: facade.network.publicKeyToAddress(
            multisigKeyPair.publicKey).toString(),
        mosaics: [{
            mosaicId: generateMosaicAliasId('symbol.xym'),
            amount: 1_000_000n // 1 XYM
        }]
    });

    // Build the wrapper aggregate transaction
    const transaction = facade.transactionFactory.create({
        type: 'aggregate_complete_transaction_v3',
        // This is the account that will pay for the transaction
        signerPublicKey: cosignatoryKeyPair.publicKey.toString(),
        deadline: timestamp.addHours(2).timestamp,
        transactionsHash: facade.static.hashEmbeddedTransactions(
            [transferTransaction]),
        transactions: [transferTransaction]
    });
    transaction.fee = new models.Amount(feeMult * transaction.size);

    // Sign the aggregate transaction using the cosignatory's signature
    const jsonPayload = facade.transactionFactory.static.attachSignature(
        transaction,
        facade.signTransaction(cosignatoryKeyPair, transaction));
    console.log('Built transaction:');
    console.dir(transaction.toJson(), { colors: true });

    // Announce the transaction
    const announcePath = '/transactions';
    console.log('Announcing transaction to', announcePath);
    const announceResponse = await fetch(`${NODE_URL}${announcePath}`, {
        method: 'PUT',
        headers: { 'Content-Type': 'application/json' },
        body: jsonPayload
    });
    console.log('  Response:', await announceResponse.text());

    // Wait for confirmation
    const transactionHash =
        facade.hashTransaction(transaction).toString();
    const statusPath = `/transactionStatus/${transactionHash}`;
    console.log('Waiting for confirmation from', statusPath);

    let attempt = 0;

    function pollStatus() {
        attempt++;

        if (attempt > 60) {
            console.warn('Confirmation took too long.');
            return;
        }

        return fetch(`${NODE_URL}${statusPath}`)
            .then(response => {
                if (!response.ok) {
                    console.log('  Transaction status: unknown | Cause:',
                        response.statusText);
                    // HTTP error: schedule a retry
                    return new Promise(resolve =>
                        setTimeout(resolve, 1000)).then(pollStatus);
                }
                return response.json();
            })
            .then(status => {
                // Skip if previous step scheduled a retry
                if (!status) return;

                console.log('  Transaction status:', status.group);

                if (status.group === 'confirmed') {
                    console.log('Transaction confirmed in', attempt,
                        'seconds');
                } else if (status.group === 'failed') {
                    console.log('Transaction failed:', status.code);
                } else {
                    // Transaction unconfirmed: schedule a retry
                    return new Promise(resolve =>
                        setTimeout(resolve, 1000)).then(pollStatus);
                }
            });
    }
    pollStatus();
} catch (e) {
    console.error(e.message, '| Cause:', e.cause?.code ?? 'unknown');
}

Download source

コード解説⚓︎

一般的に、マルチシグアカウントの代理でトランザクションに署名するには、必要な連署を提供するアグリゲートトランザクションでラップするだけで済みます。

このチュートリアルでは、転送の起点となるマルチシグアカウントを署名者として、転送内容を含む埋め込みトランザクションを構築します。その後、トランザクションを承認できるアカウントである連署者が署名したアグリゲートコンプリートトランザクションで、その転送トランザクションをラップします。

アカウントの設定⚓︎

Python JavaScript

MULTISIG_PRIVATE_KEY = os.getenv(
    'MULTISIG_PRIVATE_KEY',
    '0000000000000000000000000000000000000000000000000000000000000001')
multisig_key_pair = SymbolFacade.KeyPair(
    PrivateKey(MULTISIG_PRIVATE_KEY))
print(f'Multisig public key: {multisig_key_pair.public_key}')
COSIGNATORY0_PRIVATE_KEY = os.getenv(
    'COSIGNATORY0_PRIVATE_KEY',
    '0000000000000000000000000000000000000000000000000000000000000002')
cosignatory_key_pair = SymbolFacade.KeyPair(
    PrivateKey(COSIGNATORY0_PRIVATE_KEY))
print(f'Cosignatory public key: {cosignatory_key_pair.public_key}')

const MULTISIG_PRIVATE_KEY = process.env.MULTISIG_PRIVATE_KEY || (
    '0000000000000000000000000000000000000000000000000000000000000001');
const multisigKeyPair = new SymbolFacade.KeyPair(
    new PrivateKey(MULTISIG_PRIVATE_KEY));
console.log(`Multisig public key: ${multisigKeyPair.publicKey}`);
const COSIGNATORY0_PRIVATE_KEY = process.env.COSIGNATORY0_PRIVATE_KEY || (
    '0000000000000000000000000000000000000000000000000000000000000002');
const cosignatoryKeyPair = new SymbolFacade.KeyPair(
    new PrivateKey(COSIGNATORY0_PRIVATE_KEY));
console.log(`Cosignatory public key: ${cosignatoryKeyPair.publicKey}`);

このチュートリアルでは2つの個別のアカウントが必要です。それらの秘密鍵は環境変数を通じて提供できます。設定されていない場合は、デフォルト値が使用されます。

環境変数	デフォルト値	用途
`MULTISIG_PRIVATE_KEY`	`0000..0001`	マルチシグアカウント
`COSIGNATORY0_PRIVATE_KEY`	`0000..0002`	連署者アカウント

各秘密鍵は64文字の16進数文字列です。

連署者アカウントは、トランザクション手数料を支払うのに十分な資金を保有している必要があります。デフォルト値を使用する場合、これらのアカウントにはすでに資金が供給されている可能性があります。

上記のスニペットは、後で使用するために各アカウントのキーペアを派生させて保存します。

ネットワーク時間と手数料の取得⚓︎

Python JavaScript

    # Fetch current network time
    time_path = '/node/time'
    print(f'Fetching current network time from {time_path}')
    with urllib.request.urlopen(f'{NODE_URL}{time_path}') as response:
        response_json = json.loads(response.read().decode())
        timestamp = NetworkTimestamp(int(
            response_json['communicationTimestamps']['receiveTimestamp']))
        print(f'  Network time: {timestamp.timestamp} ms since nemesis')

    # Fetch recommended fees
    fee_path = '/network/fees/transaction'
    print(f'Fetching recommended fees from {fee_path}')
    with urllib.request.urlopen(f'{NODE_URL}{fee_path}') as response:
        response_json = json.loads(response.read().decode())
        median_mult = response_json['medianFeeMultiplier']
        minimum_mult = response_json['minFeeMultiplier']
        fee_mult = max(median_mult, minimum_mult)
        print(f'  Fee multiplier: {fee_mult}')

    // Fetch current network time
    const timePath = '/node/time';
    console.log('Fetching current network time from', timePath);
    const timeResponse = await fetch(`${NODE_URL}${timePath}`);
    const timeJSON = await timeResponse.json();
    const timestamp = new NetworkTimestamp(
        timeJSON.communicationTimestamps.receiveTimestamp);
    console.log('  Network time:', timestamp.timestamp,
        'ms since nemesis');

    // Fetch recommended fees
    const feePath = '/network/fees/transaction';
    console.log('Fetching recommended fees from', feePath);
    const feeResponse = await fetch(`${NODE_URL}${feePath}`);
    const feeJSON = await feeResponse.json();
    const medianMult = feeJSON.medianFeeMultiplier;
    const minimumMult = feeJSON.minFeeMultiplier;
    const feeMult = Math.max(medianMult, minimumMult);
    console.log('  Fee multiplier:', feeMult);

転送トランザクションチュートリアルで説明されているプロセスに従い、ネットワーク時間と推奨手数料をそれぞれ /node/time GET および /network/fees/transaction GET から取得します。

トランザクションの構築⚓︎

Python JavaScript

    # Build the embedded transfer transaction
    transfer_transaction = facade.transaction_factory.create_embedded({
        'type': 'transfer_transaction_v1',
        'signer_public_key': multisig_key_pair.public_key,
        'recipient_address':
            facade.network.public_key_to_address(
                multisig_key_pair.public_key),
        'mosaics': [{
            'mosaic_id': generate_mosaic_alias_id('symbol.xym'),
            'amount': 1_000_000 # 1 XYM
        }]
    })

    // Build the embedded transfer transaction
    const transferTransaction = facade.transactionFactory.createEmbedded({
        type: 'transfer_transaction_v1',
        signerPublicKey: multisigKeyPair.publicKey.toString(),
        recipientAddress: facade.network.publicKeyToAddress(
            multisigKeyPair.publicKey).toString(),
        mosaics: [{
            mosaicId: generateMosaicAliasId('symbol.xym'),
            amount: 1_000_000n // 1 XYM
        }]
    });

埋め込まれた転送トランザクションには以下のフィールドが含まれます。

signer_public_key: 資金の転送元となるアカウント、つまりマルチシグアカウントの公開鍵。
recipient_address: この例では、資金は送信元に戻されるため、受信者もマルチシグアカウントになります。
mosaics: 転送トランザクションチュートリアルで説明されているように、1 XYM に相当する symbol.xym モザイクの 1,000,000 絶対量。

埋め込みトランザクションは、内部トランザクションが1つだけの場合でも、アグリゲートトランザクションにラップされます。

Python JavaScript

    # Build the wrapper aggregate transaction
    transaction = facade.transaction_factory.create({
        'type': 'aggregate_complete_transaction_v3',
        # This is the account that will pay for the transaction
        'signer_public_key': cosignatory_key_pair.public_key,
        'deadline': timestamp.add_hours(2).timestamp,
        'transactions_hash': facade.hash_embedded_transactions(
            [transfer_transaction]),
        'transactions': [transfer_transaction]
    })
    transaction.fee = Amount(fee_mult * transaction.size)

    // Build the wrapper aggregate transaction
    const transaction = facade.transactionFactory.create({
        type: 'aggregate_complete_transaction_v3',
        // This is the account that will pay for the transaction
        signerPublicKey: cosignatoryKeyPair.publicKey.toString(),
        deadline: timestamp.addHours(2).timestamp,
        transactionsHash: facade.static.hashEmbeddedTransactions(
            [transferTransaction]),
        transactions: [transferTransaction]
    });
    transaction.fee = new models.Amount(feeMult * transaction.size);

主なフィールドは以下の通りです。

signer_public_key: 今回は、トランザクションを承認し、その手数料を支払う連署者の公開鍵です。
transactions: 埋め込みトランザクションのリスト。この例では1つだけですが、いくつでも含めることができます。

簡単にするため、このチュートリアルではアグリゲートコンプリートトランザクションを使用します。詳細については、コンプリートおよびボンデッドアグリゲートトランザクションのチュートリアルを参照してください。

最後に、連署者によってアグリゲートトランザクションに署名が行われます。

Python JavaScript

    # Sign the aggregate transaction using the cosignatory's signature
    json_payload = facade.transaction_factory.attach_signature(
        transaction,
        facade.sign_transaction(cosignatory_key_pair, transaction))
    print('Built transaction:')
    print(json.dumps(transaction.to_json(), indent=2))

    // Sign the aggregate transaction using the cosignatory's signature
    const jsonPayload = facade.transactionFactory.static.attachSignature(
        transaction,
        facade.signTransaction(cosignatoryKeyPair, transaction));
    console.log('Built transaction:');
    console.dir(transaction.toJson(), { colors: true });

複数の連署者

他のマルチシグ構成では、より多くの署名が必要になる場合があります。その場合、 SymbolFacade.sign_transactionSymbolFacade.signTransaction ではなく SymbolFacade.cosign_transactionSymbolFacade.cosignTransaction を使用して署名を付加します。

例についてはマルチシグアカウントの設定チュートリアルを参照してください。

アグリゲートトランザクションの送信⚓︎

最後のステップは、転送トランザクションチュートリアルで説明されているように、トランザクションをアナウンスして承認を待つことです。

Python JavaScript

    # Announce the transaction
    announce_path = '/transactions'
    print(f'Announcing transaction to {announce_path}')
    announce_request = urllib.request.Request(
        f'{NODE_URL}{announce_path}',
        data=json_payload.encode(),
        headers={ 'Content-Type': 'application/json' },
        method='PUT'
    )
    with urllib.request.urlopen(announce_request) as response:
        print(f'  Response: {response.read().decode()}')

    # Wait for confirmation
    status_path = (
        f'/transactionStatus/{facade.hash_transaction(transaction)}')
    print(f'Waiting for confirmation from {status_path}')
    for attempt in range(60):
        time.sleep(1)
        try:
            with urllib.request.urlopen(
                f'{NODE_URL}{status_path}'
            ) as response:
                status = json.loads(response.read().decode())
                print(f'  Transaction status: {status['group']}')
                if status['group'] == 'confirmed':
                    print(f'Transaction confirmed in {attempt} seconds')
                    break
                if status['group'] == 'failed':
                    print(f'Transaction failed: {status['code']}')
                    break
        except urllib.error.HTTPError as e:
            print(f'  Transaction status: unknown | Cause: ({e.msg})')
    else:
        print('Confirmation took too long.')

    // Announce the transaction
    const announcePath = '/transactions';
    console.log('Announcing transaction to', announcePath);
    const announceResponse = await fetch(`${NODE_URL}${announcePath}`, {
        method: 'PUT',
        headers: { 'Content-Type': 'application/json' },
        body: jsonPayload
    });
    console.log('  Response:', await announceResponse.text());

    // Wait for confirmation
    const transactionHash =
        facade.hashTransaction(transaction).toString();
    const statusPath = `/transactionStatus/${transactionHash}`;
    console.log('Waiting for confirmation from', statusPath);

    let attempt = 0;

    function pollStatus() {
        attempt++;

        if (attempt > 60) {
            console.warn('Confirmation took too long.');
            return;
        }

        return fetch(`${NODE_URL}${statusPath}`)
            .then(response => {
                if (!response.ok) {
                    console.log('  Transaction status: unknown | Cause:',
                        response.statusText);
                    // HTTP error: schedule a retry
                    return new Promise(resolve =>
                        setTimeout(resolve, 1000)).then(pollStatus);
                }
                return response.json();
            })
            .then(status => {
                // Skip if previous step scheduled a retry
                if (!status) return;

                console.log('  Transaction status:', status.group);

                if (status.group === 'confirmed') {
                    console.log('Transaction confirmed in', attempt,
                        'seconds');
                } else if (status.group === 'failed') {
                    console.log('Transaction failed:', status.code);
                } else {
                    // Transaction unconfirmed: schedule a retry
                    return new Promise(resolve =>
                        setTimeout(resolve, 1000)).then(pollStatus);
                }
            });
    }
    pollStatus();

プロトコル制約に違反した場合、トランザクションは拒否されます。以下の表は、最も一般的なエラーの原因をまとめたものです。

エラーメッセージ	考えられる原因
Multisig Operation Prohibited By Account	マルチシグアカウント自体がアグリゲートトランザクションに署名しようとした。
Aggregate Ineligible Cosignatories	署名者が連署者リストに含まれていない。
Consumer Batch Signature Not Verifiable	アグリゲートトランザクションに付加された署名が、その `signer_public_key` と一致しない。

出力⚓︎

以下に示す出力は、プログラムの典型的な実行結果に対応しています。

Using node https://reference.symboltest.net:3001
Multisig public key: 4CB5ABF6AD79FBF5ABBCCAFCC269D85CD2651ED4B885B5869F241AEDF0A5BA29
Cosignatory public key: 7422B9887598068E32C4448A949ADB290D0F4E35B9E01B0EE5F1A1E600FE2674
Fetching current network time from /node/time
  Network time: 102872650165 ms since nemesis
Fetching recommended fees from /network/fees/transaction
  Fee multiplier: 100
Built transaction:
{
  "signature": "A533F9B281174AE537944B25752DB75FFC277CBC3958347E741E53CA4A1D02EBA9C4B6F993DF05A250F07C270E2CF6C21DA6344FE31AE701390BA5AD7BC62F0C",
  "signer_public_key": "7422B9887598068E32C4448A949ADB290D0F4E35B9E01B0EE5F1A1E600FE2674",
  "version": 3,
  "network": 152,
  "type": 16705,
  "fee": "26400",
  "deadline": "102879850165",
  "transactions_hash": "8E64E490EB8B7887CAE6BE6846F67ADEEAE0AF3525CF98D84044ADE9F6BA488F",
  "transactions": [
    {
      "signer_public_key": "4CB5ABF6AD79FBF5ABBCCAFCC269D85CD2651ED4B885B5869F241AEDF0A5BA29",
      "version": 1,
      "network": 152,
      "type": 16724,
      "recipient_address": "987D075454716222F609929E883174AD8C996D5828C938BC",
      "mosaics": [
        {
          "mosaic_id": "16666583871264174062",
          "amount": "1000000"
        }
      ],
      "message": ""
    }
  ],
  "cosignatures": []
}
Announcing transaction to /transactions
  Response: {"message":"packet 9 was pushed to the network via /transactions"}
Waiting for confirmation from /transactionStatus/AB9FB75C150AD471AC73A6CF278D82D122E2583CF02B3B9067274608A7D334E4
  Transaction status: unconfirmed
  Transaction status: unconfirmed
  ...
  Transaction status: confirmed
Transaction confirmed in 9 seconds

出力の主なポイント:

2-3行目: 関与するすべてのアカウントの公開鍵。
11行目 (signer_public_key): アグリゲートトランザクションの署名者。連署者アカウントと一致していることに注目してください。
20行目 (signer_public_key): 埋め込まれた転送トランザクションの署名者。マルチシグアカウントと一致していることに注目してください。
24行目 (recipient_address): エンコードされたマルチシグアカウントのアドレス。

出力に示されているトランザクションハッシュを使用して、Symbol Testnet Explorer でトランザクションを検索できます。

結論⚓︎

このチュートリアルは機能的には転送トランザクションチュートリアルと同じですが、送信元アカウントとして [マルチシグアカウント] (default:マルチシグアカウント) を使用しています。

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

ステップ	関連ドキュメント
転送トランザクションを埋め込みトランザクションにラップする	`TransactionFactory.create_embeddedSymbolTransactionFactory.createEmbedded`
適切な場所に署名を付加する	`SymbolFacade.sign_transactionSymbolFacade.signTransaction`