Skip to content

Adding Restrictions to an Account⚓︎

ADVANCED

Accounts can enforce limits on:

  • which other Accounts they can interact with
  • which mosaics they can transact with
  • which types of operations they can perform

These limits are configured using account restrictions.

This tutorial demonstrates how to restrict an account's outgoing transactions so that it can only send transactions to a single authorized address.

If the restriction is already enabled, the tutorial instead demonstrates how to remove it.

After enabling or disabling the restriction, a test transfer transaction to an unauthorized address is announced, showing how the network rejects it.

Difference with Mosaic Restrictions

Symbol also supports mosaic restrictions, which are defined at the mosaic level rather than at the account level as shown in this tutorial.

These are distinct mechanisms. They are configured using different transaction types and operate under different rules.

However, account restrictions can limit which mosaics an account may interact with, and mosaic restrictions can limit which accounts may interact with a mosaic. The conceptual overlap is therefore a common source of confusion.

Prerequisites⚓︎

Before you start, make sure to:

Additionally, review the Transfer transaction 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
166
167
168
169
170
171
172
173
174
175
import json
import os
import time
import urllib.request

from symbolchain.CryptoTypes import PrivateKey
from symbolchain.facade.SymbolFacade import Address, SymbolFacade
from symbolchain.sc import AccountRestrictionFlags

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

facade = SymbolFacade('testnet')

SIGNER_PRIVATE_KEY = os.getenv('SIGNER_PRIVATE_KEY',
    '0000000000000000000000000000000000000000000000000000000000000000')
signer_key_pair = SymbolFacade.KeyPair(PrivateKey(SIGNER_PRIVATE_KEY))
signer_address = facade.network.public_key_to_address(
    signer_key_pair.public_key)
print(f'Signer address: {signer_address}')

auth_address = Address('TB6QOVCUOFRCF5QJSKPIQMLUVWGJS3KYFDETRPA')
print(f'Authorized address: {auth_address}')


# Helper function to announce a transaction
def announce_transaction(payload, label):
    print(f'Announcing {label} to /transactions')
    request = urllib.request.Request(
        f'{NODE_URL}/transactions',
        data=payload.encode(),
        headers={'Content-Type': 'application/json'},
        method='PUT'
    )
    with urllib.request.urlopen(request) as announce_response:
        print(f'  Response: {announce_response.read().decode()}')


# Helper function to wait for transaction confirmation
def wait_for_confirmation(tx_hash, label):
    print(f'Waiting for {label} confirmation...')
    for attempt in range(60):
        time.sleep(1)
        try:
            url = f'{NODE_URL}/transactionStatus/{tx_hash}'
            with urllib.request.urlopen(url) as confirm_response:
                status = json.loads(confirm_response.read().decode())
                print(f'  Transaction status: {status["group"]}')
                if status['group'] == 'confirmed':
                    print(f'{label} confirmed in {attempt} seconds')
                    return
                if status['group'] == 'failed':
                    raise RuntimeError(
                        f'{label} failed: {status["code"]}')
        except urllib.error.HTTPError:
            print('  Transaction status: unknown')
    raise TimeoutError(f'{label} not confirmed after 60 seconds')



# Returns the list of restrictions currently applied to the account
def get_account_restrictions(address):
    restrictions_path = f'/restrictions/account/{address}'
    print(f'Getting restrictions from {restrictions_path}')
    try:
        url = f'{NODE_URL}{restrictions_path}'
        with urllib.request.urlopen(url) as restr_response:
            status = json.loads(restr_response.read().decode())
            found_restr = status['accountRestrictions']['restrictions']
            print(f'  Response: {found_restr}')
            return found_restr
    except urllib.error.HTTPError:
        # The address has never been used
        print('  Response: No restrictions found')
    return []


# Returns a transaction that restricts an account
def restriction_enable_transaction():
    enable_transaction = facade.create_transaction_from_descriptor(
        {
            'type': 'account_address_restriction_transaction_v1',
            # Allow only OUTGOING transactions to the authorized ADDRESS
            'restriction_flags':
                AccountRestrictionFlags.ADDRESS |
                AccountRestrictionFlags.OUTGOING,
            # This is the only authorized outgoing address
            'restriction_additions': [auth_address]
        },
        signer_key_pair.public_key,
        fee_multiplier,
        2 * 60 * 60)
    print('Enabling the restriction with transaction:')
    print(json.dumps(enable_transaction.to_json(), indent=2))

    return enable_transaction



# Returns a transaction that removes a restriction from an account
def restriction_disable_transaction(restriction):
    disable_transaction = facade.create_transaction_from_descriptor(
        {
            'type': 'account_address_restriction_transaction_v1',
            # Lift restrictions for OUTGOING ADDRESSES
            'restriction_flags':
                AccountRestrictionFlags.ADDRESS |
                AccountRestrictionFlags.OUTGOING,
            # Remove all addresses currently restricted
            'restriction_deletions': [
                Address.from_decoded_address_hex_string(addr)
                for addr in restriction['values']
            ]
        },
        signer_key_pair.public_key,
        fee_multiplier,
        2 * 60 * 60)
    print('Disabling the restriction with transaction:')
    print(json.dumps(disable_transaction.to_json(), indent=2))

    return disable_transaction


try:
    # 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_multiplier = response_json['medianFeeMultiplier']
        minimum_multiplier = response_json['minFeeMultiplier']
        fee_multiplier = max(median_multiplier, minimum_multiplier)
        print(f'  Fee multiplier: {fee_multiplier}')

    # Get current state of the restriction and decide which
    # operation to perform
    restrictions = get_account_restrictions(signer_address)
    if len(restrictions) == 0:
        # Enable the restriction
        print('\n--- Enabling restriction ---')
        agg_transaction = restriction_enable_transaction()
    else:
        # Disable the restriction
        print('\n--- Disabling restriction ---')
        agg_transaction = restriction_disable_transaction(
            restrictions[0])

    # Sign, announce and wait for confirmation
    json_payload = facade.transaction_factory.attach_signature(
        agg_transaction,
        facade.sign_transaction(signer_key_pair, agg_transaction))
    transaction_hash = facade.hash_transaction(agg_transaction)
    announce_transaction(json_payload, 'restriction transaction')
    wait_for_confirmation(transaction_hash, 'restriction transaction')

    # Try a dummy transfer to a random address with no mosaics
    transaction = facade.create_transaction_from_descriptor(
        {
            'type': 'transfer_transaction_v1',
            'recipient_address': Address(
                'TBBHGE77IHHOIYA46B3XSORRNR2L5MLW54YO75Y')
        },
        signer_key_pair.public_key,
        fee_multiplier,
        2 * 60 * 60)
    json_payload = facade.transaction_factory.attach_signature(
        transaction,
        facade.sign_transaction(signer_key_pair, transaction))
    transaction_hash = facade.hash_transaction(transaction)
    print('\n--- Attempting transfer to unauthorized address ---')
    announce_transaction(json_payload, 'test transfer')
    wait_for_confirmation(transaction_hash, 'test transfer')

except Exception as e:
    print(e)

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
import { PrivateKey } from 'symbol-sdk';
import {
    Address,
    KeyPair,
    SymbolFacade,
    descriptors,
    models
} from 'symbol-sdk/symbol';

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

const facade = new SymbolFacade('testnet');

const SIGNER_PRIVATE_KEY = process.env.SIGNER_PRIVATE_KEY ||
    '0000000000000000000000000000000000000000000000000000000000000000';
const signerKeyPair = new KeyPair(new PrivateKey(SIGNER_PRIVATE_KEY));
const signerAddress = facade.network.publicKeyToAddress(
    signerKeyPair.publicKey);
console.log(`Signer address: ${signerAddress}`);

const authAddress = new Address('TB6QOVCUOFRCF5QJSKPIQMLUVWGJS3KYFDETRPA');
console.log(`Authorized address: ${authAddress}`);


// Helper function to announce a transaction
async function announceTransaction(payload, label) {
    console.log(`Announcing ${label} to /transactions`);
    const response = await fetch(`${NODE_URL}/transactions`, {
        method: 'PUT',
        headers: { 'Content-Type': 'application/json' },
        body: payload
    });
    console.log('  Response:', await response.text());
}

// Helper function to wait for transaction confirmation
async function waitForConfirmation(transactionHash, label) {
    console.log(`Waiting for ${label} confirmation...`);
    for (let attempt = 0; 60 > attempt; attempt++) {
        await new Promise(resolve => { setTimeout(resolve, 1000); });
        const response = await fetch(
            `${NODE_URL}/transactionStatus/${transactionHash}`);
        if (!response.ok) {
            if (404 === response.status) {
                console.log('  Transaction status: unknown');
                continue;
            }
            throw new Error(`HTTP ${response.status}`);
        }
        const status = await response.json();
        console.log('  Transaction status:', status.group);
        if ('confirmed' === status.group) {
            console.log(`${label} confirmed in`, attempt, 'seconds');
            return;
        }
        if ('failed' === status.group)
            throw new Error(`${label} failed: ${status.code}`);
    }
    throw new Error(`${label} not confirmed after 60 seconds`);
}


// Returns the list of restrictions currently applied to the account
async function getAccountRestrictions(address) {
    const restrictionsPath = `/restrictions/account/${address}`;
    console.log(`Getting restrictions from ${restrictionsPath}`);
    const response = await fetch(`${NODE_URL}${restrictionsPath}`);
    if (!response.ok) {
        console.log('  Response: No restrictions found');
        return [];
    }
    const json = await response.json();
    const restrictions = json.accountRestrictions.restrictions;
    console.log('  Response:', restrictions);
    return restrictions;
}

// Returns a transaction that restricts an account
function restrictionEnableTransaction(feeMultiplier) {
    const transaction = facade.createTransactionFromTypedDescriptor(
        new descriptors.AccountAddressRestrictionTransactionV1Descriptor(
            // Allow only OUTGOING transactions to the authorized ADDRESS
            models.AccountRestrictionFlags.ADDRESS.value |
                models.AccountRestrictionFlags.OUTGOING.value,
            // This is the only authorized outgoing address
            [authAddress],
            undefined),
        signerKeyPair.publicKey,
        feeMultiplier,
        2 * 60 * 60);
    console.log('Enabling the restriction with transaction:');
    console.dir(transaction.toJson(), { colors: true, depth: null });

    return transaction;
}

// Returns a transaction that removes a restriction from an account
function restrictionDisableTransaction(feeMultiplier, restriction) {
    const transaction = facade.createTransactionFromTypedDescriptor(
        new descriptors.AccountAddressRestrictionTransactionV1Descriptor(
            // Lift restrictions for OUTGOING ADDRESSES
            models.AccountRestrictionFlags.ADDRESS.value |
                models.AccountRestrictionFlags.OUTGOING.value,
            undefined,
            // Remove all addresses currently restricted
            restriction.values.map(hex =>
                Address.fromDecodedAddressHexString(hex))),
        signerKeyPair.publicKey,
        feeMultiplier,
        2 * 60 * 60);
    console.log('Disabling the restriction with transaction:');
    console.dir(transaction.toJson(), { colors: true, depth: null });

    return transaction;
}


try {
    // 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 medianMultiplier = feeJSON.medianFeeMultiplier;
    const minimumMultiplier = feeJSON.minFeeMultiplier;
    const feeMultiplier = Math.max(medianMultiplier, minimumMultiplier);
    console.log('  Fee multiplier:', feeMultiplier);

    // Get current state of the restriction and decide which
    // operation to perform
    const restrictions = await getAccountRestrictions(signerAddress);
    let transaction;
    if (0 === restrictions.length) {
        // Enable the restriction
        console.log('\n--- Enabling restriction ---');
        transaction = restrictionEnableTransaction(feeMultiplier);
    } else {
        // Disable the restriction
        console.log('\n--- Disabling restriction ---');
        transaction = restrictionDisableTransaction(
            feeMultiplier, restrictions[0]);
    }

    // Sign, announce and wait for confirmation
    let payload = facade.transactionFactory.static.attachSignature(
        transaction,
        facade.signTransaction(signerKeyPair, transaction));
    let hash = facade.hashTransaction(transaction).toString();
    await announceTransaction(payload, 'restriction transaction');
    await waitForConfirmation(hash, 'restriction transaction');

    // Try a dummy transfer to a random address with no mosaics
    transaction = facade.createTransactionFromTypedDescriptor(
        new descriptors.TransferTransactionV1Descriptor(
            new Address('TBBHGE77IHHOIYA46B3XSORRNR2L5MLW54YO75Y'),
            undefined,
            undefined),
        signerKeyPair.publicKey,
        feeMultiplier,
        2 * 60 * 60);
    payload = facade.transactionFactory.static.attachSignature(
        transaction,
        facade.signTransaction(signerKeyPair, transaction));
    hash = facade.hashTransaction(transaction).toString();
    console.log('\n--- Attempting transfer to unauthorized address ---');
    await announceTransaction(payload, 'test transfer');
    await waitForConfirmation(hash, 'test transfer');

} catch (e) {
    console.error(e.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
247
248
249
250
//JAVA 21+
//DEPS org.symbol:symbol-sdk:3.3.1

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.ArrayList;
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.SymbolFacade;
import org.symbol.sdk.symbol.Address;
import org.symbol.sdk.symbol.KeyPair;
import org.symbol.sdk.symbol.SymbolTransactionFactory;
import org.symbol.sdk.symbol.descriptors.*;
import org.symbol.sdk.symbol.models.*;

public final class AccountRestrictions {
    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", "https://reference.symboltest.net:3001");

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

    private KeyPair signerKeyPair;

    private Address signerAddress;

    private final Address authAddress = new Address(
        "TB6QOVCUOFRCF5QJSKPIQMLUVWGJS3KYFDETRPA");

    private void announceTransaction(
        final String payload,
        final String label
    ) throws IOException, InterruptedException {
        System.out.printf("Announcing %s to /transactions%n", label);
        final HttpRequest request = HttpRequest.newBuilder(
            URI.create(nodeUrl + "/transactions"))
            .header("Content-Type", "application/json")
            .PUT(HttpRequest.BodyPublishers.ofString(payload))
            .build();
        final HttpResponse<String> response = HTTP_CLIENT.send(
            request, BodyHandlers.ofString());
        System.out.printf("  Response: %s%n", response.body());
    }

    private void waitForConfirmation(
        final String transactionHash,
        final String label
    ) throws IOException, InterruptedException {
        System.out.printf("Waiting for %s confirmation...%n", label);
        for (int attempt = 0; 60 > attempt; ++attempt) {
            Thread.sleep(1000);
            final String statusPath =
                "/transactionStatus/" + transactionHash;
            final HttpRequest statusRequest = HttpRequest.newBuilder(
                URI.create(nodeUrl + statusPath)).GET().build();
            final HttpResponse<String> statusResponse = HTTP_CLIENT
                .send(statusRequest, BodyHandlers.ofString());
            if (404 == statusResponse.statusCode()) {
                System.out.println("  Transaction status: unknown");
                continue;
            }
            if (2 != statusResponse.statusCode() / 100)
                throw new IOException(
                    "HTTP " + statusResponse.statusCode());

            final JsonNode status =
                JSON_MAPPER.readTree(statusResponse.body());
            final String group = status.get("group").asText();
            System.out.printf("  Transaction status: %s%n", group);
            if ("confirmed".equals(group)) {
                System.out.printf("%s confirmed in %d seconds%n",
                    label, attempt);
                return;
            }
            if ("failed".equals(group))
                throw new IOException(String.format("%s failed: %s",
                    label, status.get("code").asText()));
        }
        throw new IOException(String.format(
            "%s not confirmed after 60 seconds", label));
    }

    // Returns the restrictions currently applied to the account
    private JsonNode getAccountRestrictions(
        final Address address
    ) throws IOException, InterruptedException {
        final String restrictionsPath = String.format(
            "/restrictions/account/%s", address);
        System.out.printf("Getting restrictions from %s%n",
            restrictionsPath);
        final HttpRequest request = HttpRequest.newBuilder(
            URI.create(nodeUrl + restrictionsPath)).GET().build();
        final HttpResponse<String> response = HTTP_CLIENT
            .send(request, BodyHandlers.ofString());
        if (2 != response.statusCode() / 100) {
            System.out.println("  Response: No restrictions found");
            return JSON_MAPPER.createArrayNode();
        }

        final JsonNode restrictions = JSON_MAPPER
            .readTree(response.body()).get("accountRestrictions")
            .get("restrictions");
        System.out.printf("  Response: %s%n", restrictions);
        return restrictions;
    }

    // Returns a transaction that restricts an account
    private Transaction restrictionEnableTransaction(
        final long feeMultiplier
    ) throws IOException {
        final Transaction transaction =
            facade.createTransactionFromTypedDescriptor(
                new AccountAddressRestrictionTransactionV1Descriptor(
                    new AccountRestrictionFlags(
                        AccountRestrictionFlags.ADDRESS.value |
                        AccountRestrictionFlags.OUTGOING.value),
                    List.of(authAddress),
                    null),
                signerKeyPair.getPublicKey(),
                feeMultiplier,
                2 * 60 * 60);
        System.out.println("Enabling the restriction with transaction:");
        System.out.println(JSON_MAPPER.writerWithDefaultPrettyPrinter()
            .writeValueAsString(transaction.toJson()));

        return transaction;
    }

    // Returns a transaction that removes a restriction from an account
    private Transaction restrictionDisableTransaction(
        final long feeMultiplier,
        final JsonNode restriction
    ) throws IOException {
        final List<Address> restrictionDeletions = new ArrayList<>();
        for (final JsonNode value : restriction.get("values"))
            restrictionDeletions.add(
                Address.fromDecodedAddressHexString(value.asText()));

        final Transaction transaction =
            facade.createTransactionFromTypedDescriptor(
                new AccountAddressRestrictionTransactionV1Descriptor(
                    new AccountRestrictionFlags(
                        AccountRestrictionFlags.ADDRESS.value |
                        AccountRestrictionFlags.OUTGOING.value),
                    null,
                    restrictionDeletions),
                signerKeyPair.getPublicKey(),
                feeMultiplier,
                2 * 60 * 60);
        System.out.println("Disabling the restriction with transaction:");
        System.out.println(JSON_MAPPER.writerWithDefaultPrettyPrinter()
            .writeValueAsString(transaction.toJson()));

        return transaction;
    }

    public static void main(final String[] args) {
        try {
            new AccountRestrictions().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 privateKeyString = System.getenv().getOrDefault(
            "SIGNER_PRIVATE_KEY", "0".repeat(64));
        signerKeyPair = new KeyPair(
            new CryptoTypes.PrivateKey(privateKeyString));
        signerAddress = facade.network.publicKeyToAddress(
            signerKeyPair.getPublicKey());
        System.out.printf("Signer address: %s%n", signerAddress);
        System.out.printf("Authorized address: %s%n", authAddress);


        // Fetch recommended fees
        final String feePath = "/network/fees/transaction";
        System.out.printf("Fetching recommended fees from %s%n", feePath);
        final HttpRequest feeRequest = HttpRequest.newBuilder(
            URI.create(nodeUrl + feePath)).GET().build();
        final HttpResponse<String> feeResponse = HTTP_CLIENT.send(
            feeRequest, BodyHandlers.ofString());
        final JsonNode feeJson = JSON_MAPPER.readTree(feeResponse.body());
        final long feeMultiplier = Math.max(
            feeJson.get("medianFeeMultiplier").asLong(),
            feeJson.get("minFeeMultiplier").asLong());
        System.out.printf("  Fee multiplier: %d%n", feeMultiplier);

        // Get current state of the restriction and decide which
        // operation to perform

        final JsonNode restrictions = getAccountRestrictions(
            signerAddress);
        Transaction transaction;
        if (restrictions.isEmpty()) {
            System.out.println("\n--- Enabling restriction ---");
            transaction = restrictionEnableTransaction(
                feeMultiplier);
        } else {
            System.out.println("\n--- Disabling restriction ---");
            transaction = restrictionDisableTransaction(
                feeMultiplier, restrictions.get(0));
        }

        // Sign, announce and wait for confirmation
        String payload = SymbolTransactionFactory.attachSignature(
            transaction,
            facade.signTransaction(signerKeyPair, transaction));
        String hash = facade.hashTransaction(transaction).toString();
        announceTransaction(payload, "restriction transaction");
        waitForConfirmation(hash, "restriction transaction");


        // Try a dummy transfer to a random address with no mosaics
        transaction = facade.createTransactionFromTypedDescriptor(
            new TransferTransactionV1Descriptor(
                new Address("TBBHGE77IHHOIYA46B3XSORRNR2L5MLW54YO75Y"),
                null,
                null),
            signerKeyPair.getPublicKey(),
            feeMultiplier,
            2 * 60 * 60);
        payload = SymbolTransactionFactory.attachSignature(
            transaction,
            facade.signTransaction(signerKeyPair, transaction));
        hash = facade.hashTransaction(transaction).toString();
        System.out.println(
            "\n--- Attempting transfer to unauthorized address ---");
        announceTransaction(payload, "test transfer");
        waitForConfirmation(hash, "test transfer");

    }
}

Download source

Code Explanation⚓︎

The code begins by defining two helper functions. For details on how transactions are announced and how their confirmation is tracked, refer to the Transfer transaction tutorial. The remaining helper functions are described in the sections below.

The tutorial then proceeds to:

Depending on whether the account is already restricted, a transaction is created to either:

The transaction is then announced and confirmed, and finally, a test transfer is submitted.

Setting Up the Accounts⚓︎

15
16
17
18
19
20
21
22
23
SIGNER_PRIVATE_KEY = os.getenv('SIGNER_PRIVATE_KEY',
    '0000000000000000000000000000000000000000000000000000000000000000')
signer_key_pair = SymbolFacade.KeyPair(PrivateKey(SIGNER_PRIVATE_KEY))
signer_address = facade.network.public_key_to_address(
    signer_key_pair.public_key)
print(f'Signer address: {signer_address}')

auth_address = Address('TB6QOVCUOFRCF5QJSKPIQMLUVWGJS3KYFDETRPA')
print(f'Authorized address: {auth_address}')

16
17
18
19
20
21
22
23
24
const SIGNER_PRIVATE_KEY = process.env.SIGNER_PRIVATE_KEY ||
    '0000000000000000000000000000000000000000000000000000000000000000';
const signerKeyPair = new KeyPair(new PrivateKey(SIGNER_PRIVATE_KEY));
const signerAddress = facade.network.publicKeyToAddress(
    signerKeyPair.publicKey);
console.log(`Signer address: ${signerAddress}`);

const authAddress = new Address('TB6QOVCUOFRCF5QJSKPIQMLUVWGJS3KYFDETRPA');
console.log(`Authorized address: ${authAddress}`);

183
184
185
186
187
188
189
190
        final String privateKeyString = System.getenv().getOrDefault(
            "SIGNER_PRIVATE_KEY", "0".repeat(64));
        signerKeyPair = new KeyPair(
            new CryptoTypes.PrivateKey(privateKeyString));
        signerAddress = facade.network.publicKeyToAddress(
            signerKeyPair.getPublicKey());
        System.out.printf("Signer address: %s%n", signerAddress);
        System.out.printf("Authorized address: %s%n", authAddress);

An account can only configure restrictions on itself, so this tutorial requires a single private key. The private key can be provided through the SIGNER_PRIVATE_KEY environment variable (as a 64-character hexadecimal string). If it is not provided, a default value is used.

The account must hold sufficient funds to announce transactions. If the default key is used, the corresponding account may already be funded.

At this stage, the authorized address is also configured. The restriction will later limit outgoing transactions to this address only.

125
126
127
128
129
130
131
132
133
    # 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_multiplier = response_json['medianFeeMultiplier']
        minimum_multiplier = response_json['minFeeMultiplier']
        fee_multiplier = max(median_multiplier, minimum_multiplier)
        print(f'  Fee multiplier: {fee_multiplier}')

121
122
123
124
125
126
127
128
129
    // 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 medianMultiplier = feeJSON.medianFeeMultiplier;
    const minimumMultiplier = feeJSON.minFeeMultiplier;
    const feeMultiplier = Math.max(medianMultiplier, minimumMultiplier);
    console.log('  Fee multiplier:', feeMultiplier);

193
194
195
196
197
198
199
200
201
202
203
204
        // Fetch recommended fees
        final String feePath = "/network/fees/transaction";
        System.out.printf("Fetching recommended fees from %s%n", feePath);
        final HttpRequest feeRequest = HttpRequest.newBuilder(
            URI.create(nodeUrl + feePath)).GET().build();
        final HttpResponse<String> feeResponse = HTTP_CLIENT.send(
            feeRequest, BodyHandlers.ofString());
        final JsonNode feeJson = JSON_MAPPER.readTree(feeResponse.body());
        final long feeMultiplier = Math.max(
            feeJson.get("medianFeeMultiplier").asLong(),
            feeJson.get("minFeeMultiplier").asLong());
        System.out.printf("  Fee multiplier: %d%n", feeMultiplier);

Recommended fees are fetched from /network/fees/transaction GET. The fee multiplier is used later to calculate transaction fees.

Detecting the Restriction State⚓︎

The following function retrieves the current account restrictions applied to a given address using the /restrictions/account/{address} GET endpoint. If no restrictions are configured, the function returns an empty list.

61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
# Returns the list of restrictions currently applied to the account
def get_account_restrictions(address):
    restrictions_path = f'/restrictions/account/{address}'
    print(f'Getting restrictions from {restrictions_path}')
    try:
        url = f'{NODE_URL}{restrictions_path}'
        with urllib.request.urlopen(url) as restr_response:
            status = json.loads(restr_response.read().decode())
            found_restr = status['accountRestrictions']['restrictions']
            print(f'  Response: {found_restr}')
            return found_restr
    except urllib.error.HTTPError:
        # The address has never been used
        print('  Response: No restrictions found')
    return []

65
66
67
68
69
70
71
72
73
74
75
76
77
78
// Returns the list of restrictions currently applied to the account
async function getAccountRestrictions(address) {
    const restrictionsPath = `/restrictions/account/${address}`;
    console.log(`Getting restrictions from ${restrictionsPath}`);
    const response = await fetch(`${NODE_URL}${restrictionsPath}`);
    if (!response.ok) {
        console.log('  Response: No restrictions found');
        return [];
    }
    const json = await response.json();
    const restrictions = json.accountRestrictions.restrictions;
    console.log('  Response:', restrictions);
    return restrictions;
}

 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
    private JsonNode getAccountRestrictions(
        final Address address
    ) throws IOException, InterruptedException {
        final String restrictionsPath = String.format(
            "/restrictions/account/%s", address);
        System.out.printf("Getting restrictions from %s%n",
            restrictionsPath);
        final HttpRequest request = HttpRequest.newBuilder(
            URI.create(nodeUrl + restrictionsPath)).GET().build();
        final HttpResponse<String> response = HTTP_CLIENT
            .send(request, BodyHandlers.ofString());
        if (2 != response.statusCode() / 100) {
            System.out.println("  Response: No restrictions found");
            return JSON_MAPPER.createArrayNode();
        }

        final JsonNode restrictions = JSON_MAPPER
            .readTree(response.body()).get("accountRestrictions")
            .get("restrictions");
        System.out.printf("  Response: %s%n", restrictions);
        return restrictions;
    }

The returned list is then evaluated to determine the tutorial's execution path. Based on its contents, the appropriate configuration transaction is constructed, either to enable or to remove the restriction.

135
136
137
138
139
140
141
142
143
144
145
146
    # Get current state of the restriction and decide which
    # operation to perform
    restrictions = get_account_restrictions(signer_address)
    if len(restrictions) == 0:
        # Enable the restriction
        print('\n--- Enabling restriction ---')
        agg_transaction = restriction_enable_transaction()
    else:
        # Disable the restriction
        print('\n--- Disabling restriction ---')
        agg_transaction = restriction_disable_transaction(
            restrictions[0])

131
132
133
134
135
136
137
138
139
140
141
142
143
144
    // Get current state of the restriction and decide which
    // operation to perform
    const restrictions = await getAccountRestrictions(signerAddress);
    let transaction;
    if (0 === restrictions.length) {
        // Enable the restriction
        console.log('\n--- Enabling restriction ---');
        transaction = restrictionEnableTransaction(feeMultiplier);
    } else {
        // Disable the restriction
        console.log('\n--- Disabling restriction ---');
        transaction = restrictionDisableTransaction(
            feeMultiplier, restrictions[0]);
    }

209
210
211
212
213
214
215
216
217
218
219
220
        final JsonNode restrictions = getAccountRestrictions(
            signerAddress);
        Transaction transaction;
        if (restrictions.isEmpty()) {
            System.out.println("\n--- Enabling restriction ---");
            transaction = restrictionEnableTransaction(
                feeMultiplier);
        } else {
            System.out.println("\n--- Disabling restriction ---");
            transaction = restrictionDisableTransaction(
                feeMultiplier, restrictions.get(0));
        }

If multiple restrictions are configured on the account, only the first one returned by the endpoint is removed. This situation should not occur in this tutorial.

Enabling the Restriction⚓︎

To restrict the list of addresses the account can interact with, an AccountAddressRestrictionTransactionV1 is used.

The other two account restriction types, not covered in this tutorial, are:

78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
# Returns a transaction that restricts an account
def restriction_enable_transaction():
    enable_transaction = facade.create_transaction_from_descriptor(
        {
            'type': 'account_address_restriction_transaction_v1',
            # Allow only OUTGOING transactions to the authorized ADDRESS
            'restriction_flags':
                AccountRestrictionFlags.ADDRESS |
                AccountRestrictionFlags.OUTGOING,
            # This is the only authorized outgoing address
            'restriction_additions': [auth_address]
        },
        signer_key_pair.public_key,
        fee_multiplier,
        2 * 60 * 60)
    print('Enabling the restriction with transaction:')
    print(json.dumps(enable_transaction.to_json(), indent=2))

    return enable_transaction

80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
// Returns a transaction that restricts an account
function restrictionEnableTransaction(feeMultiplier) {
    const transaction = facade.createTransactionFromTypedDescriptor(
        new descriptors.AccountAddressRestrictionTransactionV1Descriptor(
            // Allow only OUTGOING transactions to the authorized ADDRESS
            models.AccountRestrictionFlags.ADDRESS.value |
                models.AccountRestrictionFlags.OUTGOING.value,
            // This is the only authorized outgoing address
            [authAddress],
            undefined),
        signerKeyPair.publicKey,
        feeMultiplier,
        2 * 60 * 60);
    console.log('Enabling the restriction with transaction:');
    console.dir(transaction.toJson(), { colors: true, depth: null });

    return transaction;
}

120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
    private Transaction restrictionEnableTransaction(
        final long feeMultiplier
    ) throws IOException {
        final Transaction transaction =
            facade.createTransactionFromTypedDescriptor(
                new AccountAddressRestrictionTransactionV1Descriptor(
                    new AccountRestrictionFlags(
                        AccountRestrictionFlags.ADDRESS.value |
                        AccountRestrictionFlags.OUTGOING.value),
                    List.of(authAddress),
                    null),
                signerKeyPair.getPublicKey(),
                feeMultiplier,
                2 * 60 * 60);
        System.out.println("Enabling the restriction with transaction:");
        System.out.println(JSON_MAPPER.writerWithDefaultPrettyPrinter()
            .writeValueAsString(transaction.toJson()));

        return transaction;
    }

receives:

  • The transaction's descriptor: Defines AccountAddressRestrictionTransactionV1 and the restriction fields.
  • The signer public key: public key of the account whose restriction configuration will be modified.
  • The fee multiplier: Used to calculate the transaction fee.
  • The deadline duration: Set to two hours from the current time.

The transaction's descriptor contains:

  • : These are AccountRestrictionFlags.

    • ADDRESS specifies that the restriction applies to addresses. Other possible scopes are MOSAIC_ID and TRANSACTION_TYPE.
    • OUTGOING specifies that only outgoing transactions are affected. Incoming transaction restrictions can be configured independently by omitting this flag.

    By default, the listed values form an allowlist. Only the specified addresses are allowed.

    To configure the restriction in blocklist mode, where the listed addresses are forbidden, include the BLOCK flag.

  • : list of addresses (or mosaic IDs, or transaction types) to be added to the restriction.

    In this case, the list contains only the authorized address.

Removing the Restriction⚓︎

Disabling the restriction requires removing the addresses for the set of restriction flags used when enabling it.

100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
# Returns a transaction that removes a restriction from an account
def restriction_disable_transaction(restriction):
    disable_transaction = facade.create_transaction_from_descriptor(
        {
            'type': 'account_address_restriction_transaction_v1',
            # Lift restrictions for OUTGOING ADDRESSES
            'restriction_flags':
                AccountRestrictionFlags.ADDRESS |
                AccountRestrictionFlags.OUTGOING,
            # Remove all addresses currently restricted
            'restriction_deletions': [
                Address.from_decoded_address_hex_string(addr)
                for addr in restriction['values']
            ]
        },
        signer_key_pair.public_key,
        fee_multiplier,
        2 * 60 * 60)
    print('Disabling the restriction with transaction:')
    print(json.dumps(disable_transaction.to_json(), indent=2))

    return disable_transaction

 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
// Returns a transaction that removes a restriction from an account
function restrictionDisableTransaction(feeMultiplier, restriction) {
    const transaction = facade.createTransactionFromTypedDescriptor(
        new descriptors.AccountAddressRestrictionTransactionV1Descriptor(
            // Lift restrictions for OUTGOING ADDRESSES
            models.AccountRestrictionFlags.ADDRESS.value |
                models.AccountRestrictionFlags.OUTGOING.value,
            undefined,
            // Remove all addresses currently restricted
            restriction.values.map(hex =>
                Address.fromDecodedAddressHexString(hex))),
        signerKeyPair.publicKey,
        feeMultiplier,
        2 * 60 * 60);
    console.log('Disabling the restriction with transaction:');
    console.dir(transaction.toJson(), { colors: true, depth: null });

    return transaction;
}

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
    private Transaction restrictionDisableTransaction(
        final long feeMultiplier,
        final JsonNode restriction
    ) throws IOException {
        final List<Address> restrictionDeletions = new ArrayList<>();
        for (final JsonNode value : restriction.get("values"))
            restrictionDeletions.add(
                Address.fromDecodedAddressHexString(value.asText()));

        final Transaction transaction =
            facade.createTransactionFromTypedDescriptor(
                new AccountAddressRestrictionTransactionV1Descriptor(
                    new AccountRestrictionFlags(
                        AccountRestrictionFlags.ADDRESS.value |
                        AccountRestrictionFlags.OUTGOING.value),
                    null,
                    restrictionDeletions),
                signerKeyPair.getPublicKey(),
                feeMultiplier,
                2 * 60 * 60);
        System.out.println("Disabling the restriction with transaction:");
        System.out.println(JSON_MAPPER.writerWithDefaultPrettyPrinter()
            .writeValueAsString(transaction.toJson()));

        return transaction;
    }

receives the transaction's descriptor, signer public key, fee multiplier, and deadline duration.

The same values used when enabling the restriction are provided again.

The addresses currently configured in the restriction are supplied in the field so they can be removed from the configuration.

The method converts the hexadecimal string format returned by the REST API into the address representation expected when constructing a transaction.

Submitting the Transaction⚓︎

The constructed transaction is signed, announced and confirmed as described in the Transfer transaction tutorial.

148
149
150
151
152
153
154
    # Sign, announce and wait for confirmation
    json_payload = facade.transaction_factory.attach_signature(
        agg_transaction,
        facade.sign_transaction(signer_key_pair, agg_transaction))
    transaction_hash = facade.hash_transaction(agg_transaction)
    announce_transaction(json_payload, 'restriction transaction')
    wait_for_confirmation(transaction_hash, 'restriction transaction')

146
147
148
149
150
151
152
    // Sign, announce and wait for confirmation
    let payload = facade.transactionFactory.static.attachSignature(
        transaction,
        facade.signTransaction(signerKeyPair, transaction));
    let hash = facade.hashTransaction(transaction).toString();
    await announceTransaction(payload, 'restriction transaction');
    await waitForConfirmation(hash, 'restriction transaction');

222
223
224
225
226
227
228
        // Sign, announce and wait for confirmation
        String payload = SymbolTransactionFactory.attachSignature(
            transaction,
            facade.signTransaction(signerKeyPair, transaction));
        String hash = facade.hashTransaction(transaction).toString();
        announceTransaction(payload, "restriction transaction");
        waitForConfirmation(hash, "restriction transaction");

Sending a Test Transfer⚓︎

A test transfer is then attempted to an unauthorized address.

156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
    # Try a dummy transfer to a random address with no mosaics
    transaction = facade.create_transaction_from_descriptor(
        {
            'type': 'transfer_transaction_v1',
            'recipient_address': Address(
                'TBBHGE77IHHOIYA46B3XSORRNR2L5MLW54YO75Y')
        },
        signer_key_pair.public_key,
        fee_multiplier,
        2 * 60 * 60)
    json_payload = facade.transaction_factory.attach_signature(
        transaction,
        facade.sign_transaction(signer_key_pair, transaction))
    transaction_hash = facade.hash_transaction(transaction)
    print('\n--- Attempting transfer to unauthorized address ---')
    announce_transaction(json_payload, 'test transfer')
    wait_for_confirmation(transaction_hash, 'test transfer')

154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
    // Try a dummy transfer to a random address with no mosaics
    transaction = facade.createTransactionFromTypedDescriptor(
        new descriptors.TransferTransactionV1Descriptor(
            new Address('TBBHGE77IHHOIYA46B3XSORRNR2L5MLW54YO75Y'),
            undefined,
            undefined),
        signerKeyPair.publicKey,
        feeMultiplier,
        2 * 60 * 60);
    payload = facade.transactionFactory.static.attachSignature(
        transaction,
        facade.signTransaction(signerKeyPair, transaction));
    hash = facade.hashTransaction(transaction).toString();
    console.log('\n--- Attempting transfer to unauthorized address ---');
    await announceTransaction(payload, 'test transfer');
    await waitForConfirmation(hash, 'test transfer');

231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
        // Try a dummy transfer to a random address with no mosaics
        transaction = facade.createTransactionFromTypedDescriptor(
            new TransferTransactionV1Descriptor(
                new Address("TBBHGE77IHHOIYA46B3XSORRNR2L5MLW54YO75Y"),
                null,
                null),
            signerKeyPair.getPublicKey(),
            feeMultiplier,
            2 * 60 * 60);
        payload = SymbolTransactionFactory.attachSignature(
            transaction,
            facade.signTransaction(signerKeyPair, transaction));
        hash = facade.hashTransaction(transaction).toString();
        System.out.println(
            "\n--- Attempting transfer to unauthorized address ---");
        announceTransaction(payload, "test transfer");
        waitForConfirmation(hash, "test transfer");

If the restriction has been enabled, the transfer fails with an Address_Interaction_Prohibited error. If the restriction has been removed, the transfer is confirmed successfully.

The restriction configuration transaction and the test transfer are announced and confirmed independently. Each requires its own confirmation, which may increase the total execution time.

The process could be optimized by embedding both transactions in a single aggregate transaction and announcing them together.

Output⚓︎

The output shown below corresponds to two typical runs 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
Using node https://reference.symboltest.net:3001
Signer address: TCHBDENCLKEBILBPWP3JPB2XNY64OE7PYHHE32I
Authorized address: TB6QOVCUOFRCF5QJSKPIQMLUVWGJS3KYFDETRPA
Fetching recommended fees from /network/fees/transaction
  Fee multiplier: 100
Getting restrictions from /restrictions/account/TCHBDENCLKEBILBPWP3JPB2XNY64OE7PYHHE32I
  Response: No restrictions found

--- Enabling restriction ---
Enabling the restriction with transaction:
{
  "signature": "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
  "signer_public_key": "3B6A27BCCEB6A42D62A3A8D02A6F0D73653215771DE243A63AC048A18B59DA29",
  "version": 1,
  "network": 152,
  "type": 16720,
  "fee": "16000",
  "deadline": "104105847293",
  "restriction_flags": 16385,
  "restriction_additions": [
    "987D075454716222F609929E883174AD8C996D5828C938BC"
  ],
  "restriction_deletions": []
}
Announcing restriction transaction to /transactions
  Response: {"message":"packet 9 was pushed to the network via /transactions"}
Waiting for restriction transaction confirmation...
  Transaction status: unconfirmed
  Transaction status: unconfirmed
  ...
  Transaction status: confirmed
restriction transaction confirmed in 6 seconds

--- Attempting transfer to unauthorized address ---
Announcing test transfer to /transactions
  Response: {"message":"packet 9 was pushed to the network via /transactions"}
Waiting for test transfer confirmation...
  Transaction status: failed
test transfer failed: Failure_RestrictionAccount_Address_Interaction_Prohibited

Key points in the output:

  • Lines 2-3: Addresses of the involved accounts.
  • Line 7 (Response: No restrictions found): No restrictions are currently configured.
  • Line 19 ("restriction_flags": 16385): 0x4001 corresponds to the combination of ADDRESS and OUTGOING.
  • Line 20-22 ("restriction_additions"): List of allowed addresses, in decoded hexadecimal format. The value corresponds to the address shown in line 3.
  • Line 39 (test transfer failed): The unauthorized recipient address results in an Address_Interaction_Prohibited error, as expected.
 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
Using node https://reference.symboltest.net:3001
Signer address: TCHBDENCLKEBILBPWP3JPB2XNY64OE7PYHHE32I
Authorized address: TB6QOVCUOFRCF5QJSKPIQMLUVWGJS3KYFDETRPA
Fetching recommended fees from /network/fees/transaction
  Fee multiplier: 100
Getting restrictions from /restrictions/account/TCHBDENCLKEBILBPWP3JPB2XNY64OE7PYHHE32I
  Response: [{'restrictionFlags': 16385, 'values': ['987D075454716222F609929E883174AD8C996D5828C938BC']}]

--- Disabling restriction ---
Disabling the restriction with transaction:
{
  "signature": "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
  "signer_public_key": "3B6A27BCCEB6A42D62A3A8D02A6F0D73653215771DE243A63AC048A18B59DA29",
  "version": 1,
  "network": 152,
  "type": 16720,
  "fee": "16000",
  "deadline": "104105959668",
  "restriction_flags": 16385,
  "restriction_additions": [],
  "restriction_deletions": [
    "987D075454716222F609929E883174AD8C996D5828C938BC"
  ]
}
Announcing restriction transaction to /transactions
  Response: {"message":"packet 9 was pushed to the network via /transactions"}
Waiting for restriction transaction confirmation...
  Transaction status: unconfirmed
  Transaction status: unconfirmed
  ...
  Transaction status: confirmed
restriction transaction confirmed in 2 seconds

--- Attempting transfer to unauthorized address ---
Announcing test transfer to /transactions
  Response: {"message":"packet 9 was pushed to the network via /transactions"}
Waiting for test transfer confirmation...
  Transaction status: unconfirmed
  Transaction status: unconfirmed
  ...
  Transaction status: confirmed
test transfer confirmed in 23 seconds

Key points in the output:

  • Lines 2-3: Addresses of the involved accounts.
  • Line 7 (Response: [ ... ]): Existing restrictions are detected.
  • Line 19 (restriction_flags): Same flag value used when enabling the restriction.
  • Line 21-23 (restriction_deletions): The previously configured address is removed.
  • Line 42 (test transfer confirmed): The transfer is confirmed successfully because the restriction has been lifted.

The transaction hashes shown in the output can be used to look up the transactions in the Symbol Testnet Explorer.

Conclusion⚓︎

This tutorial showed how to:

Step Related documentation
Retrieve the current restriction configuration /restrictions/account/{address} GET
Enable a restriction , AccountAddressRestrictionTransactionV1
Remove a restriction , AccountAddressRestrictionTransactionV1
Create a test transfer , TransferTransactionV1