Add output how-tos

bindings/nodejs/examples/how_tos/outputs/features.ts

@@ -0,0 +1,93 @@
+// Copyright 2021-2023 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+    Client,
+    initLogger,
+    Utils,
+    UnlockCondition,
+    AddressUnlockCondition,
+    MetadataFeature,
+    SenderFeature,
+    TagFeature,
+    Ed25519Address,
+    IssuerFeature,
+    utf8ToHex,
+} from '@iota/sdk';
+require('dotenv').config({ path: '.env' });
+
+// Run with command:
+// yarn run-example ./how_tos/outputs/features.ts
+
+// Build ouputs with all features
+async function run() {
+    initLogger();
+
+    const client = new Client({});
+
+    try {
+        const hexAddress = Utils.bech32ToHex(
+            'rms1qpllaj0pyveqfkwxmnngz2c488hfdtmfrj3wfkgxtk4gtyrax0jaxzt70zy',
+        );
+
+        const addressUnlockCondition: UnlockCondition =
+            new AddressUnlockCondition(new Ed25519Address(hexAddress));
+
+        // Output with sender feature
+        const nftOutputWithSender = await client.buildNftOutput({
+            nftId: '0x0000000000000000000000000000000000000000000000000000000000000000',
+            unlockConditions: [addressUnlockCondition],
+            features: [new SenderFeature(new Ed25519Address(hexAddress))],
+        });
+
+        // Output with issuer feature
+        const nftOutputWithIssuer = await client.buildNftOutput({
+            nftId: '0x0000000000000000000000000000000000000000000000000000000000000000',
+            unlockConditions: [addressUnlockCondition],
+            immutableFeatures: [
+                new IssuerFeature(new Ed25519Address(hexAddress)),
+            ],
+        });
+
+        // Output with metadata feature
+        const nftOutputWithMetadata = await client.buildNftOutput({
+            nftId: '0x0000000000000000000000000000000000000000000000000000000000000000',
+            unlockConditions: [addressUnlockCondition],
+            features: [new MetadataFeature(utf8ToHex('Hello, World!'))],
+        });
+
+        // Output with immutable metadata feature
+        const nftOutputWithImmutableMetadata = await client.buildNftOutput({
+            nftId: '0x0000000000000000000000000000000000000000000000000000000000000000',
+            unlockConditions: [addressUnlockCondition],
+            immutableFeatures: [
+                new MetadataFeature(utf8ToHex('Hello, World!')),
+            ],
+        });
+
+        // Output with tag feature
+        const nftOutputWithTag = await client.buildNftOutput({
+            nftId: '0x0000000000000000000000000000000000000000000000000000000000000000',
+            unlockConditions: [addressUnlockCondition],
+            features: [new TagFeature(utf8ToHex('Hello, World!'))],
+        });
+
+        console.log(
+            JSON.stringify(
+                [
+                    nftOutputWithSender,
+                    nftOutputWithIssuer,
+                    nftOutputWithMetadata,
+                    nftOutputWithImmutableMetadata,
+                    nftOutputWithTag,
+                ],
+                null,
+                2,
+            ),
+        );
+    } catch (error) {
+        console.error('Error: ', error);
+    }
+}
+
+run().then(() => process.exit());

bindings/nodejs/examples/how_tos/outputs/unlock_conditions.ts

@@ -0,0 +1,124 @@
+// Copyright 2021-2023 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+    Client,
+    initLogger,
+    Utils,
+    UnlockCondition,
+    AddressUnlockCondition,
+    StorageDepositReturnUnlockCondition,
+    Ed25519Address,
+    ExpirationUnlockCondition,
+    TimelockUnlockCondition,
+    SimpleTokenScheme,
+    StateControllerAddressUnlockCondition,
+    GovernorAddressUnlockCondition,
+    ImmutableAliasAddressUnlockCondition,
+    AliasAddress,
+} from '@iota/sdk';
+require('dotenv').config({ path: '.env' });
+
+// Run with command:
+// yarn run-example ./how_tos/outputs/unlock_conditions.ts
+
+// Build ouputs with all unlock conditions
+async function run() {
+    initLogger();
+
+    const client = new Client({});
+
+    try {
+        const hexAddress = Utils.bech32ToHex(
+            'rms1qpllaj0pyveqfkwxmnngz2c488hfdtmfrj3wfkgxtk4gtyrax0jaxzt70zy',
+        );
+
+        const aliasHexAddress = Utils.bech32ToHex(
+            'rms1pr59qm43mjtvhcajfmupqf23x29llam88yecn6pyul80rx099krmv2fnnux',
+        );
+
+        const tokenSchema = new SimpleTokenScheme('0x32', '0x0', '0x64');
+
+        const addressUnlockCondition: UnlockCondition =
+            new AddressUnlockCondition(new Ed25519Address(hexAddress));
+
+        // Most simple output
+        const basicOutput = await client.buildBasicOutput({
+            unlockConditions: [addressUnlockCondition],
+        });
+
+        // Output with storage deposit return
+        const basicOutputWithStorageReturn = await client.buildBasicOutput({
+            unlockConditions: [
+                addressUnlockCondition,
+                new StorageDepositReturnUnlockCondition(
+                    new Ed25519Address(hexAddress),
+                    '1000000',
+                ),
+            ],
+        });
+
+        // Output with timelock
+        const basicOutputWithTimelock = await client.buildBasicOutput({
+            unlockConditions: [
+                addressUnlockCondition,
+                new TimelockUnlockCondition(1),
+            ],
+        });
+
+        // Output with expiration
+        const basicOutputWithExpiration = await client.buildBasicOutput({
+            unlockConditions: [
+                addressUnlockCondition,
+                new ExpirationUnlockCondition(
+                    new Ed25519Address(hexAddress),
+                    1,
+                ),
+            ],
+        });
+
+        // Output with governor and state controller unlock condition
+        const aliasOutput = await client.buildAliasOutput({
+            aliasId:
+                '0x0000000000000000000000000000000000000000000000000000000000000000',
+            unlockConditions: [
+                new GovernorAddressUnlockCondition(
+                    new Ed25519Address(hexAddress),
+                ),
+                new StateControllerAddressUnlockCondition(
+                    new Ed25519Address(hexAddress),
+                ),
+            ],
+        });
+
+        // Output with immutable alias unlock condition
+        const foundryOutput = await client.buildFoundryOutput({
+            serialNumber: 1,
+            tokenScheme: tokenSchema,
+            unlockConditions: [
+                new ImmutableAliasAddressUnlockCondition(
+                    new AliasAddress(aliasHexAddress),
+                ),
+            ],
+        });
+
+        console.log(
+            JSON.stringify(
+                [
+                    basicOutput,
+                    basicOutputWithStorageReturn,
+                    basicOutputWithTimelock,
+                    basicOutputWithExpiration,
+                    aliasOutput,
+                    foundryOutput,
+                ],
+                null,
+                2,
+            ),
+        );
+    } catch (error) {
+        console.error('Error: ', error);
+    }
+}
+
+run().then(() => process.exit());

bindings/python/examples/how_tos/outputs/features.py

@@ -0,0 +1,76 @@
+from iota_sdk import *
+from dotenv import load_dotenv
+import json
+
+load_dotenv()
+
+client = Client()
+
+hex_address = Utils.bech32_to_hex(
+    'rms1qpllaj0pyveqfkwxmnngz2c488hfdtmfrj3wfkgxtk4gtyrax0jaxzt70zy')
+
+address_unlock_condition = AddressUnlockCondition(
+    Ed25519Address(hex_address)
+)
+
+# Output with sender feature
+nft_output = client.build_nft_output(
+    nft_id='0x0000000000000000000000000000000000000000000000000000000000000000',
+    unlock_conditions=[
+        address_unlock_condition
+    ],
+    features=[
+        SenderFeature(Ed25519Address(hex_address))
+    ],
+)
+outputs = [nft_output]
+
+# Output with issuer feature
+nft_output = client.build_nft_output(
+    nft_id='0x0000000000000000000000000000000000000000000000000000000000000000',
+    unlock_conditions=[
+        address_unlock_condition,
+    ],
+    immutable_features=[
+        IssuerFeature(Ed25519Address(hex_address))
+    ],
+)
+outputs.append(nft_output)
+
+# Output with metadata feature
+nft_output = client.build_nft_output(
+    nft_id='0x0000000000000000000000000000000000000000000000000000000000000000',
+    unlock_conditions=[
+        address_unlock_condition,
+    ],
+    features=[
+        MetadataFeature(utf8_to_hex('Hello, World!'))
+    ],
+)
+outputs.append(nft_output)
+
+# Output with immutable metadata feature
+nft_output = client.build_nft_output(
+    nft_id='0x0000000000000000000000000000000000000000000000000000000000000000',
+    unlock_conditions=[
+        address_unlock_condition,
+    ],
+    immutable_features=[
+        MetadataFeature(utf8_to_hex('Hello, World!'))
+    ],
+)
+outputs.append(nft_output)
+
+# Output with tag feature
+nft_output = client.build_nft_output(
+    nft_id='0x0000000000000000000000000000000000000000000000000000000000000000',
+    unlock_conditions=[
+        address_unlock_condition
+    ],
+    features=[
+        TagFeature(utf8_to_hex('Hello, World!'))
+    ],
+)
+outputs.append(nft_output)
+
+print(json.dumps(outputs, indent=2))

bindings/python/examples/how_tos/outputs/unlock_conditions.py

@@ -0,0 +1,86 @@
+from iota_sdk import *
+from dotenv import load_dotenv
+import json
+
+load_dotenv()
+
+client = Client()
+
+hex_address = Utils.bech32_to_hex(
+    'rms1qpllaj0pyveqfkwxmnngz2c488hfdtmfrj3wfkgxtk4gtyrax0jaxzt70zy')
+
+alias_hex_address = Utils.bech32_to_hex(
+    'rms1pr59qm43mjtvhcajfmupqf23x29llam88yecn6pyul80rx099krmv2fnnux')
+
+address_unlock_condition = AddressUnlockCondition(
+    Ed25519Address(hex_address)
+)
+
+token_scheme = TokenScheme(50, 0, 100)
+
+# Most simple output
+basic_output = client.build_basic_output(
+    unlock_conditions=[address_unlock_condition],
+)
+outputs = [basic_output]
+
+# Output with storage deposit return
+basic_output = client.build_basic_output(
+    unlock_conditions=[
+        address_unlock_condition,
+        StorageDepositReturnUnlockCondition(
+            1000000,
+            Ed25519Address(hex_address),
+        ),
+    ],
+)
+outputs.append(basic_output)
+
+# Output with timelock
+basic_output = client.build_basic_output(
+    unlock_conditions=[
+        address_unlock_condition,
+        TimelockUnlockCondition(1),
+    ],
+)
+outputs.append(basic_output)
+
+# Output with expiration
+basic_output = client.build_basic_output(
+    unlock_conditions=[
+        address_unlock_condition,
+        ExpirationUnlockCondition(
+            1,
+            Ed25519Address(hex_address),
+        ),
+    ],
+)
+outputs.append(basic_output)
+
+# Output with governor and state controller unlock condition
+alias_output = client.build_alias_output(
+    alias_id='0x0000000000000000000000000000000000000000000000000000000000000000',
+    unlock_conditions=[
+        GovernorAddressUnlockCondition(
+            Ed25519Address(hex_address),
+        ),
+        StateControllerAddressUnlockCondition(
+            Ed25519Address(hex_address),
+        ),
+    ],
+)
+outputs.append(alias_output)
+
+# Output with immutable alias unlock condition
+foundry_output = client.build_foundry_output(
+    serial_number=1,
+    token_scheme=token_scheme,
+    unlock_conditions=[
+        ImmutableAliasAddressUnlockCondition(
+            AliasAddress(alias_hex_address),
+        ),
+    ],
+)
+outputs.append(foundry_output)
+
+print(json.dumps(outputs, indent=2))