Sirius Chain Developer Center 0.2.6

Sirius Chain Developer Center 0.2.6

  • Getting Started
  • Built-in Features
  • REST API Endpoints
  • Guides
  • Cheat Sheet

›Namespace

Account

  • Creating and opening an account
  • Getting account information
  • Getting the amount of XPX sent to an account
  • Reading transactions from an account

Account Restriction

  • Preventing spam attacks with account restrictions

Aggregate Transaction

  • Sending payouts with aggregate-complete transaction
  • Creating an escrow with aggregate bonded transaction
  • Asking for mosaics with aggregate-bonded transaction
  • Signing announced aggregate-bonded transactions

Block

  • Listening New Blocks
  • Getting block by height

Cross Chain Swaps

  • Atomic cross-chain swap between Sirius public and private chains

Metadata

  • Account Metadata
  • Mosaic Metadata
  • Namespace Metadata

Monitoring

  • Monitor transaction

Mosaic

  • Creating a mosaic
  • Getting the mosaic information
  • Getting the asset identifier behind a namespace with receipts
  • Modifying Mosaic Supply

Multisig Account

  • Converting an account to multisig
  • Modifying a multisig account
  • Creating a multi-level multisig-account
  • Sending a multisig transaction

Namespace

  • Registering a namespace
  • Registering a subnamespace
  • Getting the Namespace information
  • Linking a namespace to a mosaic
  • Linking namespace to account

Transfer Transaction

  • Transfer transaction
  • Sending an encrypted message

Linking namespace to account

Link a namespace to an account .

Prerequisites

  • XPX-Chain-SDK or XPX-Chain-CLI
  • A text editor or IDE
  • Have registered one namespace
  • Have one account with name xpx
  • Have namespace with name foo

Getting into some code

An account can link a registered name (namespace or subnamespace) with an account .

  1. Define the namespaceId and the address you want to link.
Golang
TypeScript
JavaScript
conf, err := sdk.NewConfig(context.Background(), []string{"http://localhost:3000"})
if err != nil {
panic(err)
}

// Use the default http client
client := sdk.NewClient(nil, conf)

account, err := client.NewAccountFromPrivateKey(os.Getenv("PRIVATE_KEY"))
if err != nil {
panic(err)
}

address, err := sdk.NewAddressFromRaw(os.Getenv("ADDRESS"))
if err != nil {
panic(err)
}

namespace, err := sdk.NewNamespaceIdFromName("foo")
if err != nil {
panic(err)
}
const namespaceId = new NamespaceId('foo');
const address = Address.createFromRawAddress('VD5DT3-CH4BLA-BL5HIM-EKP2TA-PUKF4N-Y3L5HR-IR54');

const transactionHttp = new TransactionHttp('http://localhost:3000');

const privateKey = process.env.PRIVATE_KEY as string;
const account = Account.createFromPrivateKey(privateKey, NetworkType.TEST_NET);
const networkGenerationHash = process.env.NETWORK_GENERATION_HASH as string;

const namespaceId = new NamespaceId('foo');
const address = Address.createFromRawAddress('VD5DT3-CH4BLA-BL5HIM-EKP2TA-PUKF4N-Y3L5HR-IR54');

const transactionHttp = new TransactionHttp('http://localhost:3000');

const privateKey = process.env.PRIVATE_KEY;
const account = Account.createFromPrivateKey(privateKey, NetworkType.TEST_NET);
const networkGenerationHash = process.env.NETWORK_GENERATION_HASH;

  1. Announce the alias transaction.
Golang
TypeScript
JavaScript
transaction, err := client.NewAddressAliasTransaction(
sdk.NewDeadline(time.Hour),
address,
namespace,
sdk.AliasLink,
)

if err != nil {
panic(err)
}

signedTransaction, err := account.Sign(transaction)
if err != nil {
panic(err)
}

_, err = client.Transaction.Announce(context.Background(), signedTransaction)
if err != nil {
panic(err)
}
const addressAliasTransaction = AliasTransaction.createForAddress(
Deadline.create(),
AliasActionType.Link,
namespaceId,
address,
NetworkType.TEST_NET
);

const signedTransaction = account.sign(addressAliasTransaction, networkGenerationHash);


transactionHttp
.announce(signedTransaction)
.subscribe(x => console.log(x), err => console.error(err));
const addressAliasTransaction = AliasTransaction.createForAddress(
Deadline.create(),
AliasActionType.Link,
namespaceId,
address,
NetworkType.TEST_NET
);

const signedTransaction = account.sign(addressAliasTransaction, networkGenerationHash);

transactionHttp
.announce(signedTransaction)
.subscribe(x => console.log(x), err => console.error(err));

If you want to unlink the alias, change alias action type toAliasActionType.Unlink.

What’s next?

Now you can send transactions to the namespace linked to the account instead of using the complete address.

Golang
TypeScript
namespace, err := sdk.NewNamespaceIdFromName("foo")
if err != nil {
panic(err)
}

transferTransaction, err := client.NewTransferTransactionWithNamespace(
sdk.NewDeadline(time.Hour),
namespace,
[]*sdk.Mosaic{},
sdk.NewPlainMessage("Test"),
)
if err != nil {
panic(err)
}
const namespaceId = new NamespaceId('foo');

const transferTransaction = TransferTransaction.create(
Deadline.create(),
namespaceId,
[],
PlainMessage.create('Test'),
NetworkType.TEST_NET);

← Linking a namespace to a mosaicTransfer transaction →
  • Prerequisites
  • Getting into some code
  • What’s next?
  • Join #general discussion
  • Ask development questions
  • Follow the dev updates
  • Explore Github
Protocol
BlockConsensus AlgorithmsCryptographyInflationNodeReceiptTransactionValidating
Built-in Features
AccountAccount FilterAggregate TransactionCross-Chain SwapsExchange MarketMetadataMosaicMultisig AccountNamespaceSuper contractTransfer Transaction
References
REST APISDKsXPX-Chain-CLICheat Sheet
Documentation Forked From NEM
Copyright © 2020 ProximaX