Skip to content

Signing a Transaction from a Multisignature Account⚓︎

INTERMEDIATE

This tutorial transfers 1 XEM from an account to itself, mirroring the Transfer XEM tutorial.

However, in this case, the source account is a multisignature account, also called multisig, and therefore it cannot initiate or sign transactions on its own. Instead, it relies on its cosignatory accounts to create transactions and sign them on its behalf.

The multisig account used in this tutorial is configured as a 2-of-2 multisig. It has two cosignatories, and both signatures are required to approve the transfer.

Cosignatory 0 initiates the transfer, and Cosignatory 1 provides the second required cosignature:

Multisignature TreeMultisignature AccountMultisignature AccountCosignatory 0Cosignatory 0Cosignatory 0->Multisignature AccountCosignatory 1Cosignatory 1Cosignatory 1->Multisignature Account

Alternative: WebSockets

In this tutorial, the cosignatory discovers the pending transaction by querying the node. For a WebSocket-based approach, where the cosignatory is notified in real time, see the Listening to Multisig Transaction Flow tutorial.

Prerequisites⚓︎

Before you start, make sure to:

Additionally, review the Transfer XEM tutorial to understand how transactions are announced and confirmed.

Full Code⚓︎

The following is the complete code listing for this tutorial. A detailed, step-by-step explanation follows in the next section.

  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
import json
import os
import time
import urllib.request

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

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


# Helper function to announce a transaction
def announce_transaction(payload, label):
    announce_path = '/transaction/announce'
    print(f'Announcing {label} to {announce_path}')
    request = urllib.request.Request(
        f'{NODE_URL}{announce_path}',
        data=payload.encode(),
        headers={'Content-Type': 'application/json'},
        method='POST'
    )
    with urllib.request.urlopen(request) as announce_response:
        result = json.loads(announce_response.read().decode())
    print(f'  Result: {result["message"]}')
    return result['message']


# 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
    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.')


facade = NemFacade('testnet')

MULTISIG_PUBLIC_KEY = os.getenv(
    'MULTISIG_PUBLIC_KEY',
    'D656155B48D4E71E4C59EC6FAEB5EB4F214DE8BC3C65D5BF6A3D9931B4E5ACF2')
multisig_public_key = PublicKey(MULTISIG_PUBLIC_KEY)
multisig_address = facade.network.public_key_to_address(
    multisig_public_key)
print(f'Multisig public key: {multisig_public_key}')
COSIGNATORY0_PRIVATE_KEY = os.getenv(
    'COSIGNATORY0_PRIVATE_KEY',
    '0000000000000000000000000000000000000000000000000000000000000002')
cosignatory0_key_pair = NemFacade.KeyPair(
    PrivateKey(COSIGNATORY0_PRIVATE_KEY))
print(f'Cosignatory 0 public key: {cosignatory0_key_pair.public_key}')
COSIGNATORY1_PRIVATE_KEY = os.getenv(
    'COSIGNATORY1_PRIVATE_KEY',
    '0000000000000000000000000000000000000000000000000000000000000003')
cosignatory1_key_pair = NemFacade.KeyPair(
    PrivateKey(COSIGNATORY1_PRIVATE_KEY))
print(f'Cosignatory 1 public key: {cosignatory1_key_pair.public_key}')


try:
    # Build the inner transfer transaction
    transfer_transaction = facade.create_transaction_from_descriptor({
        'type': 'transfer_transaction_v2',
        'recipient_address': multisig_address,
        'amount': 1_000_000  # 1 XEM
    }, multisig_public_key, 0, 2 * 60 * 60)
    transfer_transaction.fee = Amount(
        calculate_transaction_fee(transfer_transaction))

    # Build the wrapper multisig transaction
    transaction = facade.create_transaction_from_descriptor(
        {
            'type': 'multisig_transaction_v1',
            'inner_transaction':
                facade.transaction_factory.to_non_verifiable_transaction(
                    transfer_transaction)
        },
        # This is the cosignatory that initiates the transfer
        cosignatory0_key_pair.public_key,
        0,
        2 * 60 * 60)
    transaction.fee = Amount(calculate_transaction_fee(transaction))

    # Sign and announce the multisig transaction
    signature = facade.sign_transaction(
        cosignatory0_key_pair, transaction)
    json_payload = facade.transaction_factory.attach_signature(
        transaction, signature)
    print('Built multisig transaction:')
    print(json.dumps(transaction.to_json(), indent=2))
    transaction_hash = facade.hash_transaction(transaction)
    print(f'Transaction hash: {transaction_hash}')
    announce_result = announce_transaction(
        json_payload, 'multisig transaction')
    # The transaction is now waiting for the second signature

    # Retrieve the pending transaction from the network
    if 'SUCCESS' == announce_result:
        cosignatory1_address = facade.network.public_key_to_address(
            cosignatory1_key_pair.public_key)
        unconfirmed_path = ('/account/unconfirmedTransactions'
            f'?address={cosignatory1_address}')
        print(f'Fetching pending transactions from {unconfirmed_path}')
        with urllib.request.urlopen(
            f'{NODE_URL}{unconfirmed_path}'
        ) as response:
            pending = json.loads(response.read().decode())['data']
        # Select the pending transaction issued by the multisig account
        inner_transaction_hash = next(
            entry['meta']['data'] for entry in pending
            if entry['transaction'].get('otherTrans', {}).get(
                'signer', '').upper() == str(multisig_public_key))
        print(f'  Inner transaction hash: {inner_transaction_hash}')

        # Build the cosignature
        cosignature = facade.create_transaction_from_descriptor(
            {
                'type': 'cosignature_v1',
                # Hash of the inner transfer transaction
                'other_transaction_hash': inner_transaction_hash,
                # Address of the multisig account
                'multisig_account_address': multisig_address
            },
            # This is the cosignatory providing the second signature
            cosignatory1_key_pair.public_key,
            0,
            2 * 60 * 60)
        cosignature.fee = Amount(calculate_transaction_fee(cosignature))

        # Sign and announce the cosignature
        cosignature_signature = facade.sign_transaction(
            cosignatory1_key_pair, cosignature)
        cosignature_payload = facade.transaction_factory.attach_signature(
            cosignature, cosignature_signature)
        print('Built cosignature:')
        print(json.dumps(cosignature.to_json(), indent=2))
        cosignature_result = announce_transaction(
            cosignature_payload, 'cosignature')

        # Wait for the multisig transaction to be confirmed
        if 'SUCCESS' == cosignature_result:
            wait_for_confirmation(transaction_hash, 'multisig transaction')
        else:
            print(f'Transaction rejected: {cosignature_result}')

    else:
        print(f'Transaction rejected: {announce_result}')
except Exception as error:
    print(error)

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
import { Hash256, PrivateKey, PublicKey } from 'symbol-sdk';
import {
    Address,
    NemFacade,
    calculateTransactionFee,
    descriptors,
    models
} from 'symbol-sdk/nem';

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

// Helper function to announce a transaction
async function announceTransaction(payload, label) {
    const announcePath = '/transaction/announce';
    console.log(`Announcing ${label} to ${announcePath}`);
    const response = await fetch(`${NODE_URL}${announcePath}`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: payload
    });
    if (!response.ok)
        throw new Error(`HTTP ${response.status}`);
    const result = await response.json();
    console.log('  Result:', result.message);
    return result.message;
}

// 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;
    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 {
            const 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.`);
}

const facade = new NemFacade('testnet');

const MULTISIG_PUBLIC_KEY = process.env.MULTISIG_PUBLIC_KEY || (
    'D656155B48D4E71E4C59EC6FAEB5EB4F214DE8BC3C65D5BF6A3D9931B4E5ACF2');
const multisigPublicKey = new PublicKey(MULTISIG_PUBLIC_KEY);
const multisigAddress = facade.network.publicKeyToAddress(
    multisigPublicKey);
console.log(`Multisig public key: ${multisigPublicKey}`);
const COSIGNATORY0_PRIVATE_KEY = process.env.COSIGNATORY0_PRIVATE_KEY || (
    '0000000000000000000000000000000000000000000000000000000000000002');
const cosignatory0KeyPair = new NemFacade.KeyPair(
    new PrivateKey(COSIGNATORY0_PRIVATE_KEY));
console.log(`Cosignatory 0 public key: ${cosignatory0KeyPair.publicKey}`);
const COSIGNATORY1_PRIVATE_KEY = process.env.COSIGNATORY1_PRIVATE_KEY || (
    '0000000000000000000000000000000000000000000000000000000000000003');
const cosignatory1KeyPair = new NemFacade.KeyPair(
    new PrivateKey(COSIGNATORY1_PRIVATE_KEY));
console.log(`Cosignatory 1 public key: ${cosignatory1KeyPair.publicKey}`);


try {
    // Build the inner transfer transaction
    const transferTransaction = facade.createTransactionFromTypedDescriptor(
        new descriptors.TransferTransactionV2Descriptor(
            new Address(multisigAddress.toString()),
            new models.Amount(1_000_000n)), // 1 XEM
        multisigPublicKey,
        0n,
        2 * 60 * 60);
    transferTransaction.fee = new models.Amount(
        calculateTransactionFee(transferTransaction));

    // Build the wrapper multisig transaction
    const transaction = facade.createTransactionFromTypedDescriptor(
        new descriptors.MultisigTransactionV1Descriptor(
            facade.transactionFactory.static.toNonVerifiableTransaction(
                transferTransaction)),
        // This is the cosignatory that initiates the transfer
        cosignatory0KeyPair.publicKey,
        0n,
        2 * 60 * 60);
    transaction.fee = new models.Amount(
        calculateTransactionFee(transaction));

    // Sign and announce the multisig transaction
    const signature = facade.signTransaction(
        cosignatory0KeyPair, transaction);
    const jsonPayload = facade.transactionFactory.static.attachSignature(
        transaction, signature);
    console.log('Built multisig transaction:');
    console.log(JSON.stringify(transaction.toJson(), null, 2));
    const transactionHash = facade.hashTransaction(transaction).toString();
    console.log('Transaction hash:', transactionHash);
    const announceResult = await announceTransaction(
        jsonPayload, 'multisig transaction');
    // The transaction is now waiting for the second signature

    // Retrieve the pending transaction from the network
    if ('SUCCESS' === announceResult) {
        const cosignatory1Address = facade.network.publicKeyToAddress(
            cosignatory1KeyPair.publicKey);
        const unconfirmedPath = '/account/unconfirmedTransactions' +
            `?address=${cosignatory1Address}`;
        console.log('Fetching pending transactions from',
            unconfirmedPath);
        const unconfirmedResponse = await fetch(
            `${NODE_URL}${unconfirmedPath}`);
        const pending = (await unconfirmedResponse.json()).data;
        // Select the pending transaction issued by the multisig account
        const pendingEntry = pending.find(entry =>
            multisigPublicKey.toString() === (entry.transaction
                .otherTrans?.signer ?? '').toUpperCase());
        const innerTransactionHash = pendingEntry.meta.data;
        console.log('  Inner transaction hash:', innerTransactionHash);

        // Build the cosignature
        const cosignature = facade.createTransactionFromTypedDescriptor(
            new descriptors.CosignatureV1Descriptor(
                // Hash of the inner transfer transaction
                new Hash256(innerTransactionHash),
                // Address of the multisig account
                new Address(multisigAddress.toString())),
            // This is the cosignatory providing the second signature
            cosignatory1KeyPair.publicKey,
            0n,
            2 * 60 * 60);
        cosignature.fee = new models.Amount(
            calculateTransactionFee(cosignature));

        // Sign and announce the cosignature
        const cosignatureSignature = facade.signTransaction(
            cosignatory1KeyPair, cosignature);
        const cosignaturePayload = facade.transactionFactory.static
            .attachSignature(cosignature, cosignatureSignature);
        console.log('Built cosignature:');
        console.log(JSON.stringify(cosignature.toJson(), null, 2));
        const cosignatureResult = await announceTransaction(
            cosignaturePayload, 'cosignature');

        // Wait for the multisig transaction to be confirmed
        if ('SUCCESS' === cosignatureResult) {
            await waitForConfirmation(
                transactionHash, 'multisig transaction');
        } else {
            console.log('Transaction rejected:', cosignatureResult);
        }

    } else {
        console.log('Transaction rejected:', announceResult);
    }
} catch (e) {
    console.error(e.message, '| Cause:', e.cause?.code ?? 'unknown');
}

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
//JAVA 21+
//DEPS org.symbol:symbol-sdk:3.3.3

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.List;

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

import org.symbol.sdk.CryptoTypes;
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.NemTransactionFactory;
import org.symbol.sdk.nem.descriptors.CosignatureV1Descriptor;
import org.symbol.sdk.nem.descriptors.MultisigTransactionV1Descriptor;
import org.symbol.sdk.nem.descriptors.TransferTransactionV2Descriptor;
import org.symbol.sdk.nem.models.Amount;
import org.symbol.sdk.nem.models.Transaction;

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

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

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

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

    // Helper method to announce a transaction
    private String announceTransaction(
        final String payload,
        final String label
    ) throws IOException, InterruptedException {
        final String announcePath = "/transaction/announce";
        System.out.printf("Announcing %s to %s%n", label, announcePath);
        final HttpRequest request = HttpRequest.newBuilder(
            URI.create(nodeUrl + announcePath))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload))
            .build();
        final HttpResponse<String> response = HTTP_CLIENT.send(
            request, BodyHandlers.ofString());
        if (2 != response.statusCode() / 100)
            throw new IOException("HTTP " + response.statusCode());
        final String result = JSON_MAPPER.readTree(response.body())
            .get("message").asText();
        System.out.printf("  Result: %s%n", result);
        return result;
    }

    // Helper method to wait for transaction confirmation
    private void 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;
        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 {
                final JsonNode 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);
    }

    public static void main(final String[] args) {
        try {
            new SignMultisig().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);


        final String multisigPublicKeyString = System.getenv()
            .getOrDefault(
            "MULTISIG_PUBLIC_KEY",
            "D656155B48D4E71E4C59EC6FAEB5EB4F214DE8BC3C65D5BF6A3D9931B4E5"
                + "ACF2");
        final CryptoTypes.PublicKey multisigPublicKey =
            new CryptoTypes.PublicKey(multisigPublicKeyString);
        final Address multisigAddress = facade.network.publicKeyToAddress(
            multisigPublicKey);
        System.out.printf("Multisig public key: %s%n", multisigPublicKey);
        final KeyPair cosignatory0KeyPair = new KeyPair(
            new CryptoTypes.PrivateKey(System.getenv().getOrDefault(
                "COSIGNATORY0_PRIVATE_KEY", "0".repeat(63) + "2")));
        System.out.printf("Cosignatory 0 public key: %s%n",
            cosignatory0KeyPair.getPublicKey());
        final KeyPair cosignatory1KeyPair = new KeyPair(
            new CryptoTypes.PrivateKey(System.getenv().getOrDefault(
                "COSIGNATORY1_PRIVATE_KEY", "0".repeat(63) + "3")));
        System.out.printf("Cosignatory 1 public key: %s%n",
            cosignatory1KeyPair.getPublicKey());

        // Build the inner transfer transaction
        final Transaction transferTransaction =
            facade.createTransactionFromTypedDescriptor(
                new TransferTransactionV2Descriptor(
                    new Address(multisigAddress.toString()),
                    new Amount(1_000_000), null, List.of()), // 1 XEM
                multisigPublicKey, 0, 2 * 60 * 60);
        transferTransaction.setFee(new Amount(
            FeeCalculator.calculateTransactionFee(transferTransaction)));

        // Build the wrapper multisig transaction
        final Transaction transaction =
            facade.createTransactionFromTypedDescriptor(
                new MultisigTransactionV1Descriptor(
                    NemTransactionFactory.toNonVerifiableTransaction(
                        transferTransaction),
                    List.of()),
                // This is the cosignatory that initiates the transfer
                cosignatory0KeyPair.getPublicKey(), 0, 2 * 60 * 60);
        transaction.setFee(new Amount(
            FeeCalculator.calculateTransactionFee(transaction)));

        // Sign and announce the multisig transaction
        final CryptoTypes.Signature signature = facade.signTransaction(
            cosignatory0KeyPair, transaction);
        final String payload = NemTransactionFactory.attachSignature(
            transaction, signature);
        System.out.println("Built multisig transaction:");
        System.out.println(JSON_MAPPER.writerWithDefaultPrettyPrinter()
            .writeValueAsString(transaction.toJson()));
        final String transactionHash = facade.hashTransaction(transaction)
            .toString();
        System.out.printf("Transaction hash: %s%n", transactionHash);
        final String announceResult = announceTransaction(
            payload, "multisig transaction");
        // The transaction is now waiting for the second signature

        // Retrieve the pending transaction from the network
        if ("SUCCESS".equals(announceResult)) {
            final Address cosignatory1Address =
                facade.network.publicKeyToAddress(
                    cosignatory1KeyPair.getPublicKey());
            final String path = String.format(
                "/account/unconfirmedTransactions?address=%s",
                cosignatory1Address);
            System.out.printf("Fetching pending transactions from %s%n",
                path);
            final HttpRequest request = HttpRequest.newBuilder(
                URI.create(nodeUrl + path)).GET().build();
            final JsonNode pending = JSON_MAPPER.readTree(HTTP_CLIENT.send(
                request, BodyHandlers.ofString()).body()).get("data");
            // Select the pending transaction issued by the multisig
            JsonNode pendingEntry = null;
            for (final JsonNode entry : pending) {
                final JsonNode otherTransaction = entry.get("transaction")
                    .get("otherTrans");
                if (null != otherTransaction
                    && multisigPublicKeyString.equalsIgnoreCase(
                        otherTransaction.get("signer").asText())) {
                    pendingEntry = entry;
                    break;
                }
            }
            if (null == pendingEntry)
                throw new IOException("Pending transaction not found");
            final String innerTransactionHash = pendingEntry.get("meta")
                .get("data").asText();
            System.out.printf("  Inner transaction hash: %s%n",
                innerTransactionHash);

            // Build the cosignature
            final Transaction cosignature =
                facade.createTransactionFromTypedDescriptor(
                    new CosignatureV1Descriptor(
                        // Hash of the inner transfer transaction
                        new CryptoTypes.Hash256(innerTransactionHash),
                        // Address of the multisig account
                        new Address(multisigAddress.toString())),
                    // Cosignatory providing the second signature
                    cosignatory1KeyPair.getPublicKey(), 0, 2 * 60 * 60);
            cosignature.setFee(new Amount(
                FeeCalculator.calculateTransactionFee(cosignature)));

            // Sign and announce the cosignature
            final CryptoTypes.Signature cosignatureSignature =
                facade.signTransaction(cosignatory1KeyPair, cosignature);
            final String cosignaturePayload =
                NemTransactionFactory.attachSignature(
                    cosignature, cosignatureSignature);
            System.out.println("Built cosignature:");
            System.out.println(JSON_MAPPER.writerWithDefaultPrettyPrinter()
                .writeValueAsString(cosignature.toJson()));
            final String cosignatureResult = announceTransaction(
                cosignaturePayload, "cosignature");

            // Wait for the multisig transaction to be confirmed
            if ("SUCCESS".equals(cosignatureResult))
                waitForConfirmation(
                    transactionHash, "multisig transaction");
            else
                System.out.printf("Transaction rejected: %s%n",
                    cosignatureResult);

        } else {
            System.out.printf(
                "Transaction rejected: %s%n", announceResult);
        }
    }
}

Download source

Code Explanation⚓︎

Signing a transaction on behalf of a multisig account involves wrapping it in a MultisigTransactionV1 and collecting the required cosignatures.

In this tutorial, the wrapped transaction is a transfer, with the multisig account as its signer, since this is the origin of the funds. Cosignatory 0 signs and announces the wrapper, and the transaction remains pending until Cosignatory 1 provides the second required cosignature.

In practice, each cosignatory would run its own part on a different machine, holding only its own private key. This tutorial combines both roles in a single program for simplicity.

The code defines two helper functions for announcing a transaction and waiting for its confirmation. For details on how these work, see the Transfer XEM tutorial.

Setting Up the Accounts⚓︎

55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
MULTISIG_PUBLIC_KEY = os.getenv(
    'MULTISIG_PUBLIC_KEY',
    'D656155B48D4E71E4C59EC6FAEB5EB4F214DE8BC3C65D5BF6A3D9931B4E5ACF2')
multisig_public_key = PublicKey(MULTISIG_PUBLIC_KEY)
multisig_address = facade.network.public_key_to_address(
    multisig_public_key)
print(f'Multisig public key: {multisig_public_key}')
COSIGNATORY0_PRIVATE_KEY = os.getenv(
    'COSIGNATORY0_PRIVATE_KEY',
    '0000000000000000000000000000000000000000000000000000000000000002')
cosignatory0_key_pair = NemFacade.KeyPair(
    PrivateKey(COSIGNATORY0_PRIVATE_KEY))
print(f'Cosignatory 0 public key: {cosignatory0_key_pair.public_key}')
COSIGNATORY1_PRIVATE_KEY = os.getenv(
    'COSIGNATORY1_PRIVATE_KEY',
    '0000000000000000000000000000000000000000000000000000000000000003')
cosignatory1_key_pair = NemFacade.KeyPair(
    PrivateKey(COSIGNATORY1_PRIVATE_KEY))
print(f'Cosignatory 1 public key: {cosignatory1_key_pair.public_key}')

54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
const MULTISIG_PUBLIC_KEY = process.env.MULTISIG_PUBLIC_KEY || (
    'D656155B48D4E71E4C59EC6FAEB5EB4F214DE8BC3C65D5BF6A3D9931B4E5ACF2');
const multisigPublicKey = new PublicKey(MULTISIG_PUBLIC_KEY);
const multisigAddress = facade.network.publicKeyToAddress(
    multisigPublicKey);
console.log(`Multisig public key: ${multisigPublicKey}`);
const COSIGNATORY0_PRIVATE_KEY = process.env.COSIGNATORY0_PRIVATE_KEY || (
    '0000000000000000000000000000000000000000000000000000000000000002');
const cosignatory0KeyPair = new NemFacade.KeyPair(
    new PrivateKey(COSIGNATORY0_PRIVATE_KEY));
console.log(`Cosignatory 0 public key: ${cosignatory0KeyPair.publicKey}`);
const COSIGNATORY1_PRIVATE_KEY = process.env.COSIGNATORY1_PRIVATE_KEY || (
    '0000000000000000000000000000000000000000000000000000000000000003');
const cosignatory1KeyPair = new NemFacade.KeyPair(
    new PrivateKey(COSIGNATORY1_PRIVATE_KEY));
console.log(`Cosignatory 1 public key: ${cosignatory1KeyPair.publicKey}`);

105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
        final String multisigPublicKeyString = System.getenv()
            .getOrDefault(
            "MULTISIG_PUBLIC_KEY",
            "D656155B48D4E71E4C59EC6FAEB5EB4F214DE8BC3C65D5BF6A3D9931B4E5"
                + "ACF2");
        final CryptoTypes.PublicKey multisigPublicKey =
            new CryptoTypes.PublicKey(multisigPublicKeyString);
        final Address multisigAddress = facade.network.publicKeyToAddress(
            multisigPublicKey);
        System.out.printf("Multisig public key: %s%n", multisigPublicKey);
        final KeyPair cosignatory0KeyPair = new KeyPair(
            new CryptoTypes.PrivateKey(System.getenv().getOrDefault(
                "COSIGNATORY0_PRIVATE_KEY", "0".repeat(63) + "2")));
        System.out.printf("Cosignatory 0 public key: %s%n",
            cosignatory0KeyPair.getPublicKey());
        final KeyPair cosignatory1KeyPair = new KeyPair(
            new CryptoTypes.PrivateKey(System.getenv().getOrDefault(
                "COSIGNATORY1_PRIVATE_KEY", "0".repeat(63) + "3")));
        System.out.printf("Cosignatory 1 public key: %s%n",
            cosignatory1KeyPair.getPublicKey());

The tutorial requires three separate accounts, configured through environment variables. If not set, default values are used:

Environment Variable Default value Purpose
MULTISIG_PUBLIC_KEY D656..ACF2 2-of-2 multisig account
COSIGNATORY0_PRIVATE_KEY 0000..0002 First cosignatory account, the initiator
COSIGNATORY1_PRIVATE_KEY 0000..0003 Second cosignatory account

Each key is a 64-character hexadecimal string.

Unlike a regular account, the multisig account cannot initiate transactions itself. Instead, its cosignatories sign on its behalf. Its private key is therefore never needed, and its public key is enough to identify the account.

The multisig account must hold enough funds to pay the transaction fees. If the default values are used, this account may already be funded.

The snippet above derives and stores the key pair of each cosignatory, and the multisig account's address, for later use.

Building the Transaction⚓︎

The transaction wrapped inside a multisig transaction is called the inner transaction, and can be any basic transaction, such as the transfer used in this tutorial or the modifications used in Configuring a Multisignature Account. Multisig transactions cannot be nested.

77
78
79
80
81
82
83
84
    # Build the inner transfer transaction
    transfer_transaction = facade.create_transaction_from_descriptor({
        'type': 'transfer_transaction_v2',
        'recipient_address': multisig_address,
        'amount': 1_000_000  # 1 XEM
    }, multisig_public_key, 0, 2 * 60 * 60)
    transfer_transaction.fee = Amount(
        calculate_transaction_fee(transfer_transaction))

73
74
75
76
77
78
79
80
81
82
    // Build the inner transfer transaction
    const transferTransaction = facade.createTransactionFromTypedDescriptor(
        new descriptors.TransferTransactionV2Descriptor(
            new Address(multisigAddress.toString()),
            new models.Amount(1_000_000n)), // 1 XEM
        multisigPublicKey,
        0n,
        2 * 60 * 60);
    transferTransaction.fee = new models.Amount(
        calculateTransactionFee(transferTransaction));

126
127
128
129
130
131
132
133
134
        // Build the inner transfer transaction
        final Transaction transferTransaction =
            facade.createTransactionFromTypedDescriptor(
                new TransferTransactionV2Descriptor(
                    new Address(multisigAddress.toString()),
                    new Amount(1_000_000), null, List.of()), // 1 XEM
                multisigPublicKey, 0, 2 * 60 * 60);
        transferTransaction.setFee(new Amount(
            FeeCalculator.calculateTransactionFee(transferTransaction)));

The inner transfer transaction includes the following fields:

  • : in this particular example, the funds are sent back to the sender, so the recipient is also the multisig account.

  • : 1'000'000 atomic units, corresponding to 1 XEM, as explained in the Transfer XEM tutorial.

The inner transaction has its own transaction fee, calculated with . For the 1 XEM sent here, the fee is 0.05 XEM, as shown in the transfer fee schedule. The multisig account's public key is passed separately to the facade as the signer.

86
87
88
89
90
91
92
93
94
95
96
97
98
    # Build the wrapper multisig transaction
    transaction = facade.create_transaction_from_descriptor(
        {
            'type': 'multisig_transaction_v1',
            'inner_transaction':
                facade.transaction_factory.to_non_verifiable_transaction(
                    transfer_transaction)
        },
        # This is the cosignatory that initiates the transfer
        cosignatory0_key_pair.public_key,
        0,
        2 * 60 * 60)
    transaction.fee = Amount(calculate_transaction_fee(transaction))

84
85
86
87
88
89
90
91
92
93
94
    // Build the wrapper multisig transaction
    const transaction = facade.createTransactionFromTypedDescriptor(
        new descriptors.MultisigTransactionV1Descriptor(
            facade.transactionFactory.static.toNonVerifiableTransaction(
                transferTransaction)),
        // This is the cosignatory that initiates the transfer
        cosignatory0KeyPair.publicKey,
        0n,
        2 * 60 * 60);
    transaction.fee = new models.Amount(
        calculateTransactionFee(transaction));

136
137
138
139
140
141
142
143
144
145
146
        // Build the wrapper multisig transaction
        final Transaction transaction =
            facade.createTransactionFromTypedDescriptor(
                new MultisigTransactionV1Descriptor(
                    NemTransactionFactory.toNonVerifiableTransaction(
                        transferTransaction),
                    List.of()),
                // This is the cosignatory that initiates the transfer
                cosignatory0KeyPair.getPublicKey(), 0, 2 * 60 * 60);
        transaction.setFee(new Amount(
            FeeCalculator.calculateTransactionFee(transaction)));

The transfer transaction is then wrapped in a MultisigTransactionV1. Its most relevant fields are:

The multisig wrapper also has its own transaction fee of 0.15 XEM, as shown in the fee schedule. All fees, and the transferred amount, are deducted from the multisig account once the transaction is confirmed. The initiating cosignatory's public key is passed separately to the facade as the wrapper's signer. For both transactions, the facade derives the timestamp and deadline from the two-hour deadline duration.

Initiator: Announcing the Multisig Transaction⚓︎

100
101
102
103
104
105
106
107
108
109
110
111
    # Sign and announce the multisig transaction
    signature = facade.sign_transaction(
        cosignatory0_key_pair, transaction)
    json_payload = facade.transaction_factory.attach_signature(
        transaction, signature)
    print('Built multisig transaction:')
    print(json.dumps(transaction.to_json(), indent=2))
    transaction_hash = facade.hash_transaction(transaction)
    print(f'Transaction hash: {transaction_hash}')
    announce_result = announce_transaction(
        json_payload, 'multisig transaction')
    # The transaction is now waiting for the second signature

 96
 97
 98
 99
100
101
102
103
104
105
106
107
    // Sign and announce the multisig transaction
    const signature = facade.signTransaction(
        cosignatory0KeyPair, transaction);
    const jsonPayload = facade.transactionFactory.static.attachSignature(
        transaction, signature);
    console.log('Built multisig transaction:');
    console.log(JSON.stringify(transaction.toJson(), null, 2));
    const transactionHash = facade.hashTransaction(transaction).toString();
    console.log('Transaction hash:', transactionHash);
    const announceResult = await announceTransaction(
        jsonPayload, 'multisig transaction');
    // The transaction is now waiting for the second signature

148
149
150
151
152
153
154
155
156
157
158
159
160
161
        // Sign and announce the multisig transaction
        final CryptoTypes.Signature signature = facade.signTransaction(
            cosignatory0KeyPair, transaction);
        final String payload = NemTransactionFactory.attachSignature(
            transaction, signature);
        System.out.println("Built multisig transaction:");
        System.out.println(JSON_MAPPER.writerWithDefaultPrettyPrinter()
            .writeValueAsString(transaction.toJson()));
        final String transactionHash = facade.hashTransaction(transaction)
            .toString();
        System.out.printf("Transaction hash: %s%n", transactionHash);
        final String announceResult = announceTransaction(
            payload, "multisig transaction");
        // The transaction is now waiting for the second signature

In this case, Cosignatory 0 is the initiator of the multisig transaction. It signs the transaction and announces it to the network.

If valid, the network accepts the transaction, but it is not confirmed yet. Since the multisig account requires two cosignatures and only one has been provided, the transaction waits in the unconfirmed pool until the missing cosignature arrives.

Simpler configurations

In a multisig that requires only one cosignature, such as the 1-of-2 configuration created in the Configuring a Multisignature Account tutorial, the initiating cosignatory's signature is enough. If valid, the transaction is confirmed without any further steps.

Cosignatory: Retrieving the Pending Transaction⚓︎

113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
    # Retrieve the pending transaction from the network
    if 'SUCCESS' == announce_result:
        cosignatory1_address = facade.network.public_key_to_address(
            cosignatory1_key_pair.public_key)
        unconfirmed_path = ('/account/unconfirmedTransactions'
            f'?address={cosignatory1_address}')
        print(f'Fetching pending transactions from {unconfirmed_path}')
        with urllib.request.urlopen(
            f'{NODE_URL}{unconfirmed_path}'
        ) as response:
            pending = json.loads(response.read().decode())['data']
        # Select the pending transaction issued by the multisig account
        inner_transaction_hash = next(
            entry['meta']['data'] for entry in pending
            if entry['transaction'].get('otherTrans', {}).get(
                'signer', '').upper() == str(multisig_public_key))
        print(f'  Inner transaction hash: {inner_transaction_hash}')

109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
    // Retrieve the pending transaction from the network
    if ('SUCCESS' === announceResult) {
        const cosignatory1Address = facade.network.publicKeyToAddress(
            cosignatory1KeyPair.publicKey);
        const unconfirmedPath = '/account/unconfirmedTransactions' +
            `?address=${cosignatory1Address}`;
        console.log('Fetching pending transactions from',
            unconfirmedPath);
        const unconfirmedResponse = await fetch(
            `${NODE_URL}${unconfirmedPath}`);
        const pending = (await unconfirmedResponse.json()).data;
        // Select the pending transaction issued by the multisig account
        const pendingEntry = pending.find(entry =>
            multisigPublicKey.toString() === (entry.transaction
                .otherTrans?.signer ?? '').toUpperCase());
        const innerTransactionHash = pendingEntry.meta.data;
        console.log('  Inner transaction hash:', innerTransactionHash);

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
        // Retrieve the pending transaction from the network
        if ("SUCCESS".equals(announceResult)) {
            final Address cosignatory1Address =
                facade.network.publicKeyToAddress(
                    cosignatory1KeyPair.getPublicKey());
            final String path = String.format(
                "/account/unconfirmedTransactions?address=%s",
                cosignatory1Address);
            System.out.printf("Fetching pending transactions from %s%n",
                path);
            final HttpRequest request = HttpRequest.newBuilder(
                URI.create(nodeUrl + path)).GET().build();
            final JsonNode pending = JSON_MAPPER.readTree(HTTP_CLIENT.send(
                request, BodyHandlers.ofString()).body()).get("data");
            // Select the pending transaction issued by the multisig
            JsonNode pendingEntry = null;
            for (final JsonNode entry : pending) {
                final JsonNode otherTransaction = entry.get("transaction")
                    .get("otherTrans");
                if (null != otherTransaction
                    && multisigPublicKeyString.equalsIgnoreCase(
                        otherTransaction.get("signer").asText())) {
                    pendingEntry = entry;
                    break;
                }
            }
            if (null == pendingEntry)
                throw new IOException("Pending transaction not found");
            final String innerTransactionHash = pendingEntry.get("meta")
                .get("data").asText();
            System.out.printf("  Inner transaction hash: %s%n",
                innerTransactionHash);

At this point, Cosignatory 1 takes over. Cosignatories can use the /account/unconfirmedTransactions GET endpoint to discover pending multisig transactions awaiting their signature.

The metadata of each pending multisig transaction contains the hash of its inner transaction, which is the value that a cosignature must reference.

A cosignatory can have multiple pending multisig transactions awaiting approval. In this example, the code selects the transaction issued by the multisig account. This approach is sufficient for the tutorial because only one pending transaction is expected from that account, and Cosignatory 1 has no prior knowledge of the transaction to match more precisely.

Alternatively, the initiator can share the inner transaction hash with the other cosignatories through an off-chain channel. The cosignatories can then match this hash to select the exact transaction.

In real applications, however, filtering by the issuing account is not enough. Nothing guarantees that a pending transaction is the expected one, so inspect the content of each pending transaction, such as its type, recipient, and amount, before selecting the one to cosign.

Verify before cosigning

Always verify the contents of a transaction before cosigning it. Cosignatures are binding and cannot be undone.

Cosignatory: Cosigning the Transaction⚓︎

131
132
133
134
135
136
137
138
139
140
141
142
143
144
        # Build the cosignature
        cosignature = facade.create_transaction_from_descriptor(
            {
                'type': 'cosignature_v1',
                # Hash of the inner transfer transaction
                'other_transaction_hash': inner_transaction_hash,
                # Address of the multisig account
                'multisig_account_address': multisig_address
            },
            # This is the cosignatory providing the second signature
            cosignatory1_key_pair.public_key,
            0,
            2 * 60 * 60)
        cosignature.fee = Amount(calculate_transaction_fee(cosignature))

127
128
129
130
131
132
133
134
135
136
137
138
139
        // Build the cosignature
        const cosignature = facade.createTransactionFromTypedDescriptor(
            new descriptors.CosignatureV1Descriptor(
                // Hash of the inner transfer transaction
                new Hash256(innerTransactionHash),
                // Address of the multisig account
                new Address(multisigAddress.toString())),
            // This is the cosignatory providing the second signature
            cosignatory1KeyPair.publicKey,
            0n,
            2 * 60 * 60);
        cosignature.fee = new models.Amount(
            calculateTransactionFee(cosignature));

196
197
198
199
200
201
202
203
204
205
206
207
            // Build the cosignature
            final Transaction cosignature =
                facade.createTransactionFromTypedDescriptor(
                    new CosignatureV1Descriptor(
                        // Hash of the inner transfer transaction
                        new CryptoTypes.Hash256(innerTransactionHash),
                        // Address of the multisig account
                        new Address(multisigAddress.toString())),
                    // Cosignatory providing the second signature
                    cosignatory1KeyPair.getPublicKey(), 0, 2 * 60 * 60);
            cosignature.setFee(new Amount(
                FeeCalculator.calculateTransactionFee(cosignature)));

Cosignatory 1 provides the missing signature by announcing a CosignatureV1. The cosignature specifies:

  • : hash of the inner transfer transaction retrieved in the previous step.

  • : address of the multisig account the signature refers to.

The cosignature has a 0.15 XEM fee. The fee is also deducted from the multisig account once the multisig transaction is confirmed. The cosignatory's public key is passed separately to the facade as the signer.

146
147
148
149
150
151
152
153
154
        # Sign and announce the cosignature
        cosignature_signature = facade.sign_transaction(
            cosignatory1_key_pair, cosignature)
        cosignature_payload = facade.transaction_factory.attach_signature(
            cosignature, cosignature_signature)
        print('Built cosignature:')
        print(json.dumps(cosignature.to_json(), indent=2))
        cosignature_result = announce_transaction(
            cosignature_payload, 'cosignature')

141
142
143
144
145
146
147
148
149
        // Sign and announce the cosignature
        const cosignatureSignature = facade.signTransaction(
            cosignatory1KeyPair, cosignature);
        const cosignaturePayload = facade.transactionFactory.static
            .attachSignature(cosignature, cosignatureSignature);
        console.log('Built cosignature:');
        console.log(JSON.stringify(cosignature.toJson(), null, 2));
        const cosignatureResult = await announceTransaction(
            cosignaturePayload, 'cosignature');

209
210
211
212
213
214
215
216
217
218
219
            // Sign and announce the cosignature
            final CryptoTypes.Signature cosignatureSignature =
                facade.signTransaction(cosignatory1KeyPair, cosignature);
            final String cosignaturePayload =
                NemTransactionFactory.attachSignature(
                    cosignature, cosignatureSignature);
            System.out.println("Built cosignature:");
            System.out.println(JSON_MAPPER.writerWithDefaultPrettyPrinter()
                .writeValueAsString(cosignature.toJson()));
            final String cosignatureResult = announceTransaction(
                cosignaturePayload, "cosignature");

Cosignatory 1 then signs the cosignature and announces it to the network.

The announced cosignature does not appear in the unconfirmed pool as a separate transaction. Instead, the network attaches it to the pending multisig transaction.

In configurations that require additional cosignatures, the transaction remains pending. The collected signatures can be inspected in the transaction's signatures field by querying /account/unconfirmedTransactions GET again.

In this tutorial, however, the second cosignature completes the transaction, which leaves the pool and is confirmed in the next block.

Waiting for Confirmation⚓︎

156
157
158
159
160
        # Wait for the multisig transaction to be confirmed
        if 'SUCCESS' == cosignature_result:
            wait_for_confirmation(transaction_hash, 'multisig transaction')
        else:
            print(f'Transaction rejected: {cosignature_result}')

151
152
153
154
155
156
157
        // Wait for the multisig transaction to be confirmed
        if ('SUCCESS' === cosignatureResult) {
            await waitForConfirmation(
                transactionHash, 'multisig transaction');
        } else {
            console.log('Transaction rejected:', cosignatureResult);
        }

221
222
223
224
225
226
227
            // Wait for the multisig transaction to be confirmed
            if ("SUCCESS".equals(cosignatureResult))
                waitForConfirmation(
                    transactionHash, "multisig transaction");
            else
                System.out.printf("Transaction rejected: %s%n",
                    cosignatureResult);

Once all required cosignatures have been collected, the multisig transaction is confirmed as a single unit.

Multisig transactions are rejected if they violate protocol constraints. The following table summarizes the most common error sources:

Error message Probable cause
FAILURE_TRANSACTION_NOT_ALLOWED_FOR_MULTISIG The multisig account tried to announce the transfer itself.
FAILURE_MULTISIG_NOT_A_COSIGNER The signer of the multisig transaction is not in the cosignatories list.
FAILURE_MULTISIG_NO_MATCHING_MULTISIG The cosignature does not match a pending multisig transaction, or its signer is not a cosignatory.

Output⚓︎

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

 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
Using node http://libertalia.nemtest.net:7890
Multisig public key: D656155B48D4E71E4C59EC6FAEB5EB4F214DE8BC3C65D5BF6A3D9931B4E5ACF2
Cosignatory 0 public key: AC1FC0D95CA3255D20C57C179EE6E694A47A725C48DB362CC4978D7745C6A5C3
Cosignatory 1 public key: 26D999AD34795F20D33886047A8CB7DE1ED0042AB7ED1017C602222C8B2A4C23
Built multisig transaction:
{
  "type": 4100,
  "version": 1,
  "network": 152,
  "timestamp": 357569945,
  "signer_public_key": "AC1FC0D95CA3255D20C57C179EE6E694A47A725C48DB362CC4978D7745C6A5C3",
  "signature": "DD065509918473534035EEFE9258E515861B250BBCF8208A77B12FE6A1AFF42F0C3D51D9A74E7A09F39C29C0CDFF860FF76F597FCE62A28433AFC8D95926A70E",
  "fee": "150000",
  "deadline": 357577145,
  "inner_transaction": {
    "type": 257,
    "version": 2,
    "network": 152,
    "timestamp": 357569945,
    "signer_public_key": "D656155B48D4E71E4C59EC6FAEB5EB4F214DE8BC3C65D5BF6A3D9931B4E5ACF2",
    "signature": "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
    "fee": "50000",
    "deadline": 357577145,
    "recipient_address": "54424C58494F554F34455035595237344859585333424642474F4E5A42554850334E495332484A36",
    "amount": "1000000",
    "mosaics": []
  },
  "cosignatures": []
}
Transaction hash: 12282A1E794D5D230EC8D0093E925F1BD83BB156F460DC2775045B61A779B8AA
Announcing multisig transaction to /transaction/announce
  Result: SUCCESS
Fetching pending transactions from /account/unconfirmedTransactions?address=TC7BQFXISQEOPN2PCPPPOM3V4R3XDPNVEHEQLID4
  Inner transaction hash: 24a1079e4dd5063c3a938675653a7525c640824470764cc34ab2a64c0c614c4d
Built cosignature:
{
  "type": 4098,
  "version": 1,
  "network": 152,
  "timestamp": 357569945,
  "signer_public_key": "26D999AD34795F20D33886047A8CB7DE1ED0042AB7ED1017C602222C8B2A4C23",
  "signature": "A094A18F4E63745B4939BB6979BD293856765E25A96B244AC7AB5E7334398802A824E800206DA62888DB474A1C64EBEBB285EC05EB3D08C8F4EA8C40A221A30D",
  "fee": "150000",
  "deadline": 357577145,
  "other_transaction_hash": "24A1079E4DD5063C3A938675653A7525C640824470764CC34AB2A64C0C614C4D",
  "multisig_account_address": "54424C58494F554F34455035595237344859585333424642474F4E5A42554850334E495332484A36"
}
Announcing cosignature to /transaction/announce
  Result: SUCCESS
Waiting for multisig transaction confirmation from /transaction/get?hash=12282A1E794D5D230EC8D0093E925F1BD83BB156F460DC2775045B61A779B8AA
  Transaction status: pending
  Transaction status: pending
  ...
multisig transaction confirmed in block 719496

Key points in the output:

  • Lines 2-4: Public keys of all involved accounts.
  • Line 11 (signer_public_key): Signer of the multisig transaction. Note that it matches Cosignatory 0.
  • Line 20 (signer_public_key): Signer of the inner transfer transaction. Note that it matches the multisig account.
  • Line 30: Hash of the multisig transaction, which uniquely identifies it on the network.
  • Line 34 (Inner transaction hash): Hash of the pending inner transaction, retrieved from the network.
  • Line 41 (signer_public_key): Signer of the cosignature. Note that it matches Cosignatory 1.
  • Line 45 (other_transaction_hash): The inner transaction hash referenced by the cosignature.

The multisig transaction hash shown in the output can be used to look up the confirmed transaction in the NEM testnet explorer.

Conclusion⚓︎

This tutorial is functionally identical to the Transfer XEM tutorial, but using a multisignature account as the source account.

In particular, the tutorial showed how to:

Step Related documentation
Wrap transfer in a multisig transaction MultisigTransactionV1,
Sign the multisig transaction
Discover pending transactions /account/unconfirmedTransactions GET
Cosign a pending multisig transaction CosignatureV1