@tech-bureau/mijin-catapult-tools 0.1.4 → 0.1.5

package/README.md

@@ -12,7 +12,13 @@ This tool is for easy operation of mijin Catapult(v.2)
   * Transaction
   * Mosaic
     * Create
-    * info
+    * Info
+  * Namespace
+    * Create Root
+    * Create Sub
+    * Link Mosaic
+    * Link Address
+    * Info
 * Voting
   * Create
   * Info
@@ -573,6 +579,75 @@ $ mijin-catapult-tools transaction mosaic create -r config.json -o work -s 1000
 2023-01-16T06:28:34.464Z [info] : http://localhost:3000/transactions/confirmed/733BA25FECEECC334CAD0E4B86F80676661EA34DC1781E205C0034536A5A330A
 ```
 
+## Namespace
+
+```bash
+$ mijin-catapult-tools transaction namespace -h
+Usage: mijin-catapult-tools transaction namespace [options] [command]
+
+Namespace Transaction Announce or Info
+
+Options:
+  -h, --help              display help for command
+
+Commands:
+  create-root [options]   Create Root Namespace and Announce Mosaic Transaction
+  create-sub [options]    Create Sub Namespace and Announce Mosaic Transaction
+  link-mosaic [options]   Link Mosaic and Announce Transaction
+  link-address [options]  Link Address and Announce Transaction
+  info [options]          Get Namespace Info
+  help [command]          display help for command
+```
+
+### Namespace Example Commands
+
+``` bash
+$ mijin-catapult-tools transaction namespace create-root -r config.json -o work -n test -d 1000
+$ mijin-catapult-tools transaction namespace create-sub -r config.json -o work -n sub -pn test
+$ mijin-catapult-tools transaction namespace create-sub -r config.json -o work -n sub2 -pn test
+$ mijin-catapult-tools transaction namespace link-mosaic -r config.json -o work -n test.sub -m 287CD558128F6C53
+$ mijin-catapult-tools transaction namespace link-address -r config.json -o work -n test.sub2 -a MDLEKG5MKKAPFBM3XWZKYQEDYRJO67MUJXFDP6I
+$ mijin-catapult-tools transaction namespace info -r config.json -n test
+```
+
+### Create Root Namespace (Owner work Account)
+
+Namespace Name: test
+Duration: 1000
+
+```bash
+$ mijin-catapult-tools transaction namespace create-root -r config.json -o work -n test -d 1000
+2023-03-10T06:11:01.298Z [info] : mijin URL: http://localhost:3000
+2023-03-10T06:11:01.299Z [info] : Network: 96
+2023-03-10T06:11:01.300Z [info] : Create Root Namespace...
+2023-03-10T06:11:01.345Z [info] : Root Namespace Owner Account: MDLEKG5MKKAPFBM3XWZKYQEDYRJO67MUJXFDP6I
+2023-03-10T06:11:01.346Z [info] : Namespace Name: test
+2023-03-10T06:11:01.348Z [info] : Namespace Transaction: {"transaction":{"type":16718,"network":96,"version":1,"maxFee":"0","deadline":"118141861343","signature":"","registrationType":0,"name":"test","id":"D401054C1965C26E","duration":"1000"}}
+2023-03-10T06:11:01.378Z [info] : Transaction Fee: 0
+2023-03-10T06:11:01.378Z [info] : Namespace Rental Fee Per Block: 1
+2023-03-10T06:11:01.378Z [info] : Start Announce Transaction...
+2023-03-10T06:11:06.415Z [info] : End Transaction
+2023-03-10T06:11:06.415Z [info] : http://localhost:3000/transactionStatus/57275DF8349C3FB582BA5B1B854FA8C270C467B8A48EB9B9E24EC6F3F7A1786B
+2023-03-10T06:11:06.415Z [info] : http://localhost:3000/transactions/confirmed/57275DF8349C3FB582BA5B1B854FA8C270C467B8A48EB9B9E24EC6F3F7A1786B
+```
+
+### Namespace Info
+
+Namespace Name: test
+
+```bash
+$ mijin-catapult-tools transaction namespace info -r config.json -n test
+2023-03-10T06:13:34.668Z [info] : mijin URL: http://localhost:3000
+2023-03-10T06:13:34.669Z [info] : Network: 96
+2023-03-10T06:13:34.670Z [info] : Namespace Id: test
+2023-03-10T06:13:34.749Z [info] : Namespace Info: {
+  "active": true,
+  "ownerAddress": "MDLEKG5MKKAPFBM3XWZKYQEDYRJO67MUJXFDP6I",
+  "namespaceId": "D401054C1965C26E",
+  "parentId": "0000000000000000"
+}
+```
+
 ## Create Votingkey Dat file(for main Account)
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tech-bureau/mijin-catapult-tools",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "This tool is for easy operation of mijin Catapult(v.2)",
   "private": false,
   "main": "dist/main.js",
@@ -52,4 +52,4 @@
     "webpack": "^5.24.2",
     "webpack-cli": "^4.5.0"
   }
-}
+}

package/src/__tests__/service/NamespaceServices.spec.ts

@@ -0,0 +1,97 @@
+import NamespaceServices from '../../service/NamespaceServices'
+import { NetworkType } from '@tech-bureau/symbol-sdk'
+
+const config = {
+  url: 'http://localhost:3000',
+  workAccount: {
+    publicKey: '65AB2F5671F285325E0A196651566D3770A1A809C4C169DDFED157E86F63ABA1',
+    privateKey: '1E33ACC3CD9F7BB01D1EDD0F560F2D9635D7E6F98D7BFB3EA7EF7EDA5303FB80',
+    address: 'MD2NEFQ75FKV5HDOTLTZNEE5SYRRMIAYFYJKA3Q',
+  },
+  balanceAccount: {
+    publicKey: '',
+    privateKey: '',
+    address: '',
+  },
+  mainAccount: {
+    publicKey: 'CF4250FA98A00C2B201D3BCB4CF5B7965C41DFBD6D331CB56F16BCC03DB79B4C',
+    privateKey: 'BFC70F2FC37D1CD31F60CE3DC11DD9CF3E0DAEA2B5D960F3456FB63AA0AC83C2',
+    address: 'MDAHM3BQQTLIA4WHWN572U35ZJG2ULVJWYCSG5I',
+  },
+  keylink: {
+    vrf: {
+      publicKey: '4DC4AFDC04F0271CFFB2B65B0A5E505184EC5AD81892B7541397D2F85F1533D3',
+      privateKey: '495656E00893DD1FB8AEF833FF1F60ED2D1D7EF050213EE4DADCC7CC01493ADF',
+      address: 'MBR6DL2MMFAG2ASPU5N4HSZPK6I6IEDKB747BRQ',
+    },
+    voting: {
+      publicKey: '937E1684027FB86BAFF47146C98F166767BD3BE3C00E1BF47657C72EBE2C3500',
+      privateKey: '1393923A4CE0547D713C9D6C5C327F23ADFB6CCEE344E173528C9119F9654F65',
+      address: 'MAL6PBEOZ4KQD4RKTUHCFA2CO2FYYGGMY77KFEA',
+    },
+  },
+  test1Account: {
+    publicKey: '49CEF8886711941127EFA8492829748D523F5C6CD4B17EA45759AFEC37BA4C22',
+    privateKey: 'D60BA72D4AA73D0845F1742F95C6CEC2F5576DE0C9AA3C4AC764C362AC93ED2C',
+    address: 'MDBZDEIYKPLEYGJ7S55TLTXH3R5JZDKP2TPLOUQ',
+  },
+  test2Account: {
+    publicKey: 'A0E0D1D095E22E49A8E679AA470A1A0B10714C27E6471F6C99D982A7FF8A025B',
+    privateKey: 'F141362C6F636FCE21BE72C2E42779202F54A91AF14A9BF6140FAA3FCC641944',
+    address: 'MAURGUI3OOJ6NF7OUYYEWS6QTAIFLJFK4EQGWZA',
+  },
+}
+
+const rootNamespaceName = 'mijin'
+const subNamespaceName = 'cat'
+const namespaceRawId = 'CF70B22792D08638'
+const mosaicRawId = '13CD4D0575AD0250'
+const epoch = 100
+const duration = 1000
+const networkType = NetworkType.MIJIN
+const minFeeMultiplier = 100
+
+describe('start namespace test', () => {
+  it('Create Root Namespace function', () => {
+    const createRootNamespace = NamespaceServices.createRootNamespace(
+      epoch,
+      rootNamespaceName,
+      duration,
+      networkType,
+      minFeeMultiplier
+    )
+    expect(createRootNamespace).toBeDefined()
+  })
+
+  it('Create Sub Namespace function', () => {
+    const createSubNamespace = NamespaceServices.createSubNamespace(
+      epoch,
+      rootNamespaceName,
+      subNamespaceName,
+      networkType,
+      minFeeMultiplier
+    )
+    expect(createSubNamespace).toBeDefined()
+  })
+  it('Create mosaic link function', () => {
+    const mosaicLink = NamespaceServices.linkMosaic(epoch, namespaceRawId, mosaicRawId, networkType, minFeeMultiplier)
+    expect(mosaicLink).toBeDefined()
+  })
+  it('Create account link function', () => {
+    const mosaicLink = NamespaceServices.linkAddress(
+      epoch,
+      namespaceRawId,
+      config.workAccount.address,
+      networkType,
+      minFeeMultiplier
+    )
+    expect(mosaicLink).toBeDefined()
+  })
+  it('Get Namespace Id function', () => {
+    const namespace = NamespaceServices.getNamespaceId(rootNamespaceName)
+    expect(namespace?.fullName).toBe(rootNamespaceName)
+
+    const namespace2 = NamespaceServices.getNamespaceId(namespaceRawId)
+    expect(namespace2?.toHex()).toBe(namespaceRawId)
+  })
+})

package/src/cli.ts

@@ -8,7 +8,7 @@ import transaction from './commands/transaction/transaction'
   program
     .name('mijin-catapult-tools')
     .description('This tool allows you to easily operate mijin Catapult')
-    .version('0.1.4')
+    .version('0.1.5')
 
   program.addCommand(account())
   program.addCommand(voting())

package/src/commands/namespace/linkAddress.ts

@@ -0,0 +1,16 @@
+import { Command } from 'commander'
+import linkAddress from '../../infrastructure/namespace/linkAddress'
+const program = new Command()
+
+program
+  .name('link-address')
+  .description('Link Address and Announce Transaction')
+  .option('-o, --owner <work|balance|main|test1|test2|other>', 'Specify the input of from Account', 'other')
+  .option('-u, --url <mijinCatapultURL>', 'Specify the input of mijin URL')
+  .option('-n, --name <name>', 'Specify the input of Namespace Name')
+  .option('-a, --address <address>', 'Specify the input of Address')
+  .option('-r, --readfile <config.json>', 'Specify the input of Read Config File')
+  .option('-p, --privatekey <privateKey>', 'Specify the input of Mosaic Owner Account Private Key')
+  .action(linkAddress)
+
+export default program

package/src/commands/namespace/linkMosaic.ts

@@ -0,0 +1,16 @@
+import { Command } from 'commander'
+import linkMosaic from '../../infrastructure/namespace/linkMosaic'
+const program = new Command()
+
+program
+  .name('link-mosaic')
+  .description('Link Mosaic and Announce Transaction')
+  .option('-o, --owner <work|balance|main|test1|test2|other>', 'Specify the input of from Account', 'other')
+  .option('-u, --url <mijinCatapultURL>', 'Specify the input of mijin URL')
+  .option('-n, --name <name>', 'Specify the input of Namespace Name')
+  .option('-m, --mosaic-id <mosaic-id>', 'Specify the input of Mosaic Id')
+  .option('-r, --readfile <config.json>', 'Specify the input of Read Config File')
+  .option('-p, --privatekey <privateKey>', 'Specify the input of Mosaic Owner Account Private Key')
+  .action(linkMosaic)
+
+export default program

package/src/commands/namespace/namespace.ts

@@ -0,0 +1,22 @@
+import { Command } from 'commander'
+import rootNamespaceCreate from './rootNamespaceCreate'
+import subNamespaceCreate from './subNamespaceCreate'
+import linkMosaic from './linkMosaic'
+import linkAddress from './linkAddress'
+import namespaceInfo from './namespaceInfo'
+
+const mosaic = () => {
+  const program = new Command('namespace')
+
+  program.description('Namespace Transaction Announce or Info')
+
+  program.addCommand(rootNamespaceCreate)
+  program.addCommand(subNamespaceCreate)
+  program.addCommand(linkMosaic)
+  program.addCommand(linkAddress)
+  program.addCommand(namespaceInfo)
+
+  return program
+}
+
+export default mosaic

package/src/commands/namespace/namespaceInfo.ts

@@ -0,0 +1,13 @@
+import { Command } from 'commander'
+import namespaceInfo from '../../infrastructure/namespace/namespaceInfo'
+const program = new Command()
+
+program
+  .name('info')
+  .description('Get Namespace Info')
+  .option('-u, --url <mijinCatapultURL>', 'Specify the input of mijin URL')
+  .option('-r, --readfile <config.json>', 'Specify the input of Read Config File')
+  .option('-n, --namespaceId <namespaceId>', 'Specify the input of Namespace Id or Name')
+  .action(namespaceInfo)
+
+export default program

package/src/commands/namespace/rootNamespaceCreate.ts

@@ -0,0 +1,16 @@
+import { Command } from 'commander'
+import rootNamespaceCreate from '../../infrastructure/namespace/rootNamespaceCreate'
+const program = new Command()
+
+program
+  .name('create-root')
+  .description('Create Root Namespace and Announce Mosaic Transaction')
+  .option('-o, --owner <work|balance|main|test1|test2|other>', 'Specify the input of from Account', 'other')
+  .option('-u, --url <mijinCatapultURL>', 'Specify the input of mijin URL')
+  .option('-d, --duration <duration>', 'Specify the input of Namespace Duration')
+  .option('-n, --name <name>', 'Specify the input of Namespace Name')
+  .option('-r, --readfile <config.json>', 'Specify the input of Read Config File')
+  .option('-p, --privatekey <privateKey>', 'Specify the input of Mosaic Owner Account Private Key')
+  .action(rootNamespaceCreate)
+
+export default program

package/src/commands/namespace/subNamespaceCreate.ts

@@ -0,0 +1,16 @@
+import { Command } from 'commander'
+import subNamespaceCreate from '../../infrastructure/namespace/subNamespaceCreate'
+const program = new Command()
+
+program
+  .name('create-sub')
+  .description('Create Sub Namespace and Announce Mosaic Transaction')
+  .option('-o, --owner <work|balance|main|test1|test2|other>', 'Specify the input of from Account', 'other')
+  .option('-u, --url <mijinCatapultURL>', 'Specify the input of mijin URL')
+  .option('-n, --name <name>', 'Specify the input of Namespace Name')
+  .option('-pn, --parent-name <parent-name>', 'Specify the input of Namespace Parent Name')
+  .option('-r, --readfile <config.json>', 'Specify the input of Read Config File')
+  .option('-p, --privatekey <privateKey>', 'Specify the input of Mosaic Owner Account Private Key')
+  .action(subNamespaceCreate)
+
+export default program

package/src/commands/transaction/transaction.ts

@@ -2,8 +2,9 @@ import { Command } from 'commander'
 import transfer from './transfer'
 import status from './transactionStatus'
 import mosaic from '../mosaic/mosaic'
+import namespace from '../namespace/namespace'
 
-const votingkey = () => {
+const transaction = () => {
   const program = new Command('transaction')
 
   program.description('Transaction Announce or Info')
@@ -11,8 +12,9 @@ const votingkey = () => {
   program.addCommand(transfer)
   program.addCommand(status)
   program.addCommand(mosaic())
+  program.addCommand(namespace())
 
   return program
 }
 
-export default votingkey
+export default transaction

package/src/infrastructure/namespace/linkAddress.ts

@@ -0,0 +1,126 @@
+import AccountServices from '../../service/AccountServices'
+import RepositoryFactory from '../../service/RepositoryFactory'
+import { INamespaceCreateOption } from '../../types'
+import LoggerFactory from '../../service/Logger'
+import { readConfig, checkFile } from '../../utils'
+import TransactionServices from '../../service/TransactionServices'
+import NamespaceServices from '../../service/NamespaceServices'
+
+const logger = LoggerFactory.getLogger()
+
+export default async (option: INamespaceCreateOption) => {
+  const { owner, url, readfile, name, address, privatekey } = option
+
+  let configFile
+
+  if (readfile && (await checkFile(readfile))) {
+    configFile = await readConfig(readfile)
+  }
+
+  const mijinUrl = url ? url : configFile ? configFile.url : undefined
+
+  if (!mijinUrl) {
+    logger.error(`Must Set mijin URL(-u http://xxxxxx.com:3000) or Set Read Config(-r config.json)`)
+    return
+  }
+
+  let repo
+
+  try {
+    repo = new RepositoryFactory(mijinUrl)
+    await repo.init()
+  } catch (error) {
+    logger.error(`Please specify a valid URL: ${mijinUrl}`)
+    return
+  }
+
+  const networkType = repo.getNetwork()
+  const epoch = repo.getEpoch()
+
+  logger.info(`mijin URL: ${mijinUrl}`)
+  logger.info(`Network: ${networkType.toString()}`)
+
+  logger.info('Link Address...')
+
+  let createAccount
+
+  switch (owner) {
+    case 'work':
+      createAccount = configFile
+        ? AccountServices.createAccount(configFile.workAccount.privateKey, networkType)
+        : undefined
+      break
+    case 'balance':
+      createAccount = configFile
+        ? AccountServices.createAccount(configFile.balanceAccount.privateKey, networkType)
+        : undefined
+      break
+    case 'main':
+      createAccount = configFile
+        ? AccountServices.createAccount(configFile.mainAccount.privateKey, networkType)
+        : undefined
+      break
+    case 'test1':
+      createAccount = configFile
+        ? AccountServices.createAccount(configFile.test1Account.privateKey, networkType)
+        : undefined
+      break
+    case 'test2':
+      createAccount = configFile
+        ? AccountServices.createAccount(configFile.test2Account.privateKey, networkType)
+        : undefined
+      break
+    default:
+      createAccount =
+        privatekey && privatekey.length === 64 ? AccountServices.createAccount(privatekey, networkType) : undefined
+      break
+  }
+
+  if (!createAccount) {
+    logger.error('Create Account Not Found Set (-r config -o owner) or -p')
+    return
+  }
+
+  if (!name) {
+    logger.error('Namespace name Not Found Set -n option')
+    return
+  }
+
+  if (!address) {
+    logger.error('Namespace link address Not Found Set -a option')
+    return
+  }
+
+  const minFeeMultiplier = repo.getTransactionFees().minFeeMultiplier
+  const mosaicLinkTransaction = NamespaceServices.linkAddress(epoch, name, address, networkType, minFeeMultiplier)
+  if (!mosaicLinkTransaction) {
+    logger.error('invalid name or address option')
+    return
+  }
+
+  logger.info(`Account: ${createAccount.address.plain()}`)
+  logger.info(`Namespace Name: ${name}`)
+  logger.info(`Namespace Link Address: ${address}`)
+  logger.info(`Namespace Transaction: ${JSON.stringify(mosaicLinkTransaction)}`)
+  const signedTransaction = createAccount.sign(mosaicLinkTransaction, repo.getGnerationHash())
+
+  logger.info(`Transaction Fee: ${repo.getTransactionFees().minFeeMultiplier}`)
+  logger.info('Start Announce Transaction...')
+
+  const announce = await TransactionServices.announce(
+    signedTransaction,
+    repo.createLitener(),
+    repo.createTransactionRepository(),
+    repo.createReceiptRepository()
+  ).catch((err) => {
+    return err
+  })
+  if (announce instanceof Error) {
+    logger.error(`Namespace Announce ${announce}`)
+    return
+  }
+
+  logger.info('End Transaction')
+  logger.info(`${mijinUrl}/transactionStatus/${signedTransaction.hash}`)
+  logger.info(`${mijinUrl}/transactions/confirmed/${signedTransaction.hash}`)
+}

package/src/infrastructure/namespace/linkMosaic.ts

@@ -0,0 +1,126 @@
+import AccountServices from '../../service/AccountServices'
+import RepositoryFactory from '../../service/RepositoryFactory'
+import { INamespaceCreateOption } from '../../types'
+import LoggerFactory from '../../service/Logger'
+import { readConfig, checkFile } from '../../utils'
+import TransactionServices from '../../service/TransactionServices'
+import NamespaceServices from '../../service/NamespaceServices'
+
+const logger = LoggerFactory.getLogger()
+
+export default async (option: INamespaceCreateOption) => {
+  const { owner, url, readfile, name, mosaicId, privatekey } = option
+
+  let configFile
+
+  if (readfile && (await checkFile(readfile))) {
+    configFile = await readConfig(readfile)
+  }
+
+  const mijinUrl = url ? url : configFile ? configFile.url : undefined
+
+  if (!mijinUrl) {
+    logger.error(`Must Set mijin URL(-u http://xxxxxx.com:3000) or Set Read Config(-r config.json)`)
+    return
+  }
+
+  let repo
+
+  try {
+    repo = new RepositoryFactory(mijinUrl)
+    await repo.init()
+  } catch (error) {
+    logger.error(`Please specify a valid URL: ${mijinUrl}`)
+    return
+  }
+
+  const networkType = repo.getNetwork()
+  const epoch = repo.getEpoch()
+
+  logger.info(`mijin URL: ${mijinUrl}`)
+  logger.info(`Network: ${networkType.toString()}`)
+
+  logger.info('Link Mosaic...')
+
+  let createAccount
+
+  switch (owner) {
+    case 'work':
+      createAccount = configFile
+        ? AccountServices.createAccount(configFile.workAccount.privateKey, networkType)
+        : undefined
+      break
+    case 'balance':
+      createAccount = configFile
+        ? AccountServices.createAccount(configFile.balanceAccount.privateKey, networkType)
+        : undefined
+      break
+    case 'main':
+      createAccount = configFile
+        ? AccountServices.createAccount(configFile.mainAccount.privateKey, networkType)
+        : undefined
+      break
+    case 'test1':
+      createAccount = configFile
+        ? AccountServices.createAccount(configFile.test1Account.privateKey, networkType)
+        : undefined
+      break
+    case 'test2':
+      createAccount = configFile
+        ? AccountServices.createAccount(configFile.test2Account.privateKey, networkType)
+        : undefined
+      break
+    default:
+      createAccount =
+        privatekey && privatekey.length === 64 ? AccountServices.createAccount(privatekey, networkType) : undefined
+      break
+  }
+
+  if (!createAccount) {
+    logger.error('Create Account Not Found Set (-r config -o owner) or -p')
+    return
+  }
+
+  if (!name) {
+    logger.error('Namespace name Not Found Set -n option')
+    return
+  }
+
+  if (!mosaicId) {
+    logger.error('Namespace Link Mosaic Id Not Found Set -m option')
+    return
+  }
+
+  const minFeeMultiplier = repo.getTransactionFees().minFeeMultiplier
+  const mosaicLinkTransaction = NamespaceServices.linkMosaic(epoch, name, mosaicId, networkType, minFeeMultiplier)
+  if (!mosaicLinkTransaction) {
+    logger.error('invalid name or mosaic option')
+    return
+  }
+
+  logger.info(`Account: ${createAccount.address.plain()}`)
+  logger.info(`Namespace Name: ${name}`)
+  logger.info(`Namespace Link Mosaic Id: ${mosaicId}`)
+  logger.info(`Namespace Transaction: ${JSON.stringify(mosaicLinkTransaction)}`)
+  const signedTransaction = createAccount.sign(mosaicLinkTransaction, repo.getGnerationHash())
+
+  logger.info(`Transaction Fee: ${repo.getTransactionFees().minFeeMultiplier}`)
+  logger.info('Start Announce Transaction...')
+
+  const announce = await TransactionServices.announce(
+    signedTransaction,
+    repo.createLitener(),
+    repo.createTransactionRepository(),
+    repo.createReceiptRepository()
+  ).catch((err) => {
+    return err
+  })
+  if (announce instanceof Error) {
+    logger.error(`Namespace Link Announce ${announce}`)
+    return
+  }
+
+  logger.info('End Transaction')
+  logger.info(`${mijinUrl}/transactionStatus/${signedTransaction.hash}`)
+  logger.info(`${mijinUrl}/transactions/confirmed/${signedTransaction.hash}`)
+}

package/src/infrastructure/namespace/namespaceInfo.ts

@@ -0,0 +1,44 @@
+import RepositoryFactory from '../../service/RepositoryFactory'
+import { INamespaceInfoOption } from '../../types'
+import LoggerFactory from '../../service/Logger'
+import { readConfig, checkFile } from '../../utils'
+import NamespaceServices from '../../service/NamespaceServices'
+
+const logger = LoggerFactory.getLogger()
+
+export default async (option: INamespaceInfoOption) => {
+  const { url, readfile, namespaceId } = option
+
+  let configFile
+
+  if (readfile && (await checkFile(readfile))) {
+    configFile = await readConfig(readfile)
+  }
+
+  if (!url && !configFile) {
+    logger.error(`Must Set mijin URL(-u http://xxxxxx.com:3000) or Set Read Config(-r config.json)`)
+    return
+  }
+
+  const mijinUrl = url ? url : configFile ? configFile.url : ''
+
+  const repo = new RepositoryFactory(mijinUrl)
+  await repo.init()
+
+  const networkType = repo.getNetwork()
+
+  logger.info(`mijin URL: ${mijinUrl}`)
+  logger.info(`Network: ${networkType.toString()}`)
+
+  if (!namespaceId) {
+    logger.error(`Must set Namespace Id`)
+    return
+  }
+  logger.info(`Namespace Id: ${namespaceId}`)
+  const namespaceInfo = await NamespaceServices.getNamespace(namespaceId, repo.createNamespaceRepository())
+  if (!namespaceInfo) {
+    logger.info(`Namespace Not Found`)
+    return
+  }
+  logger.info(`Namespace Info: ${JSON.stringify(NamespaceServices.namespaceInfo(namespaceInfo), null, '  ')}`)
+}

package/src/infrastructure/namespace/rootNamespaceCreate.ts

@@ -0,0 +1,134 @@
+import AccountServices from '../../service/AccountServices'
+import RepositoryFactory from '../../service/RepositoryFactory'
+import { INamespaceCreateOption } from '../../types'
+import LoggerFactory from '../../service/Logger'
+import { readConfig, checkFile } from '../../utils'
+import TransactionServices from '../../service/TransactionServices'
+import NamespaceServices from '../../service/NamespaceServices'
+
+const logger = LoggerFactory.getLogger()
+
+export default async (option: INamespaceCreateOption) => {
+  const { owner, url, readfile, name, duration, privatekey } = option
+
+  let configFile
+
+  if (readfile && (await checkFile(readfile))) {
+    configFile = await readConfig(readfile)
+  }
+
+  const mijinUrl = url ? url : configFile ? configFile.url : undefined
+
+  if (!mijinUrl) {
+    logger.error(`Must Set mijin URL(-u http://xxxxxx.com:3000) or Set Read Config(-r config.json)`)
+    return
+  }
+
+  let repo
+
+  try {
+    repo = new RepositoryFactory(mijinUrl)
+    await repo.init()
+  } catch (error) {
+    logger.error(`Please specify a valid URL: ${mijinUrl}`)
+    return
+  }
+
+  const networkType = repo.getNetwork()
+  const epoch = repo.getEpoch()
+
+  logger.info(`mijin URL: ${mijinUrl}`)
+  logger.info(`Network: ${networkType.toString()}`)
+
+  logger.info('Create Root Namespace...')
+
+  let createAccount
+
+  switch (owner) {
+    case 'work':
+      createAccount = configFile
+        ? AccountServices.createAccount(configFile.workAccount.privateKey, networkType)
+        : undefined
+      break
+    case 'balance':
+      createAccount = configFile
+        ? AccountServices.createAccount(configFile.balanceAccount.privateKey, networkType)
+        : undefined
+      break
+    case 'main':
+      createAccount = configFile
+        ? AccountServices.createAccount(configFile.mainAccount.privateKey, networkType)
+        : undefined
+      break
+    case 'test1':
+      createAccount = configFile
+        ? AccountServices.createAccount(configFile.test1Account.privateKey, networkType)
+        : undefined
+      break
+    case 'test2':
+      createAccount = configFile
+        ? AccountServices.createAccount(configFile.test2Account.privateKey, networkType)
+        : undefined
+      break
+    default:
+      createAccount =
+        privatekey && privatekey.length === 64 ? AccountServices.createAccount(privatekey, networkType) : undefined
+      break
+  }
+
+  if (!createAccount) {
+    logger.error('Create Account Not Found Set (-r config -o owner) or -p')
+    return
+  }
+
+  if (!duration) {
+    logger.error('duration Not Found Set -d option')
+    return
+  }
+
+  if (!name) {
+    logger.error('name Not Found Set -n option')
+    return
+  }
+
+  const minFeeMultiplier = repo.getTransactionFees().minFeeMultiplier
+  const createRootNamespaceTransaction = NamespaceServices.createRootNamespace(
+    epoch,
+    name,
+    duration,
+    networkType,
+    minFeeMultiplier
+  )
+  if (!createRootNamespaceTransaction) {
+    logger.error('invalid name option')
+    return
+  }
+
+  logger.info(`Root Namespace Owner Account: ${createAccount.address.plain()}`)
+  logger.info(`Namespace Name: ${name}`)
+  logger.info(`Namespace Transaction: ${JSON.stringify(createRootNamespaceTransaction)}`)
+  const signedTransaction = createAccount.sign(createRootNamespaceTransaction, repo.getGnerationHash())
+
+  logger.info(`Transaction Fee: ${repo.getTransactionFees().minFeeMultiplier}`)
+  logger.info(
+    `Namespace Rental Fee Per Block: ${repo.getNetworkProperties().plugins.namespace?.rootNamespaceRentalFeePerBlock}`
+  )
+  logger.info('Start Announce Transaction...')
+
+  const announce = await TransactionServices.announce(
+    signedTransaction,
+    repo.createLitener(),
+    repo.createTransactionRepository(),
+    repo.createReceiptRepository()
+  ).catch((err) => {
+    return err
+  })
+  if (announce instanceof Error) {
+    logger.error(`Namespace Announce ${announce}`)
+    return
+  }
+
+  logger.info('End Transaction')
+  logger.info(`${mijinUrl}/transactionStatus/${signedTransaction.hash}`)
+  logger.info(`${mijinUrl}/transactions/confirmed/${signedTransaction.hash}`)
+}

package/src/infrastructure/namespace/subNamespaceCreate.ts

@@ -0,0 +1,135 @@
+import AccountServices from '../../service/AccountServices'
+import RepositoryFactory from '../../service/RepositoryFactory'
+import { INamespaceCreateOption } from '../../types'
+import LoggerFactory from '../../service/Logger'
+import { readConfig, checkFile } from '../../utils'
+import TransactionServices from '../../service/TransactionServices'
+import NamespaceServices from '../../service/NamespaceServices'
+
+const logger = LoggerFactory.getLogger()
+
+export default async (option: INamespaceCreateOption) => {
+  const { owner, url, readfile, name, parentName, privatekey } = option
+
+  let configFile
+
+  if (readfile && (await checkFile(readfile))) {
+    configFile = await readConfig(readfile)
+  }
+
+  const mijinUrl = url ? url : configFile ? configFile.url : undefined
+
+  if (!mijinUrl) {
+    logger.error(`Must Set mijin URL(-u http://xxxxxx.com:3000) or Set Read Config(-r config.json)`)
+    return
+  }
+
+  let repo
+
+  try {
+    repo = new RepositoryFactory(mijinUrl)
+    await repo.init()
+  } catch (error) {
+    logger.error(`Please specify a valid URL: ${mijinUrl}`)
+    return
+  }
+
+  const networkType = repo.getNetwork()
+  const epoch = repo.getEpoch()
+
+  logger.info(`mijin URL: ${mijinUrl}`)
+  logger.info(`Network: ${networkType.toString()}`)
+
+  logger.info('Create Sub Namespace...')
+
+  let createAccount
+
+  switch (owner) {
+    case 'work':
+      createAccount = configFile
+        ? AccountServices.createAccount(configFile.workAccount.privateKey, networkType)
+        : undefined
+      break
+    case 'balance':
+      createAccount = configFile
+        ? AccountServices.createAccount(configFile.balanceAccount.privateKey, networkType)
+        : undefined
+      break
+    case 'main':
+      createAccount = configFile
+        ? AccountServices.createAccount(configFile.mainAccount.privateKey, networkType)
+        : undefined
+      break
+    case 'test1':
+      createAccount = configFile
+        ? AccountServices.createAccount(configFile.test1Account.privateKey, networkType)
+        : undefined
+      break
+    case 'test2':
+      createAccount = configFile
+        ? AccountServices.createAccount(configFile.test2Account.privateKey, networkType)
+        : undefined
+      break
+    default:
+      createAccount =
+        privatekey && privatekey.length === 64 ? AccountServices.createAccount(privatekey, networkType) : undefined
+      break
+  }
+
+  if (!createAccount) {
+    logger.error('Create Account Not Found Set (-r config -o owner) or -p')
+    return
+  }
+
+  if (!name) {
+    logger.error('Namespace name Not Found Set -n option')
+    return
+  }
+
+  if (!parentName) {
+    logger.error('Namespace parentName Not Found Set -pn option')
+    return
+  }
+
+  const minFeeMultiplier = repo.getTransactionFees().minFeeMultiplier
+  const createsubNamespaceTransaction = NamespaceServices.createSubNamespace(
+    epoch,
+    name,
+    parentName,
+    networkType,
+    minFeeMultiplier
+  )
+  if (!createsubNamespaceTransaction) {
+    logger.error('invalid name option')
+    return
+  }
+
+  logger.info(`Sub Namespace Owner Account: ${createAccount.address.plain()}`)
+  logger.info(`Namespace Name: ${name}`)
+  logger.info(`Namespace Parent Name: ${parentName}`)
+  logger.info(`Namespace Transaction: ${JSON.stringify(createsubNamespaceTransaction)}`)
+  const signedTransaction = createAccount.sign(createsubNamespaceTransaction, repo.getGnerationHash())
+
+  logger.info(`Transaction Fee: ${repo.getTransactionFees().minFeeMultiplier}`)
+  logger.info(
+    `Namespace Rental Fee Per Block: ${repo.getNetworkProperties().plugins.namespace?.rootNamespaceRentalFeePerBlock}`
+  )
+  logger.info('Start Announce Transaction...')
+
+  const announce = await TransactionServices.announce(
+    signedTransaction,
+    repo.createLitener(),
+    repo.createTransactionRepository(),
+    repo.createReceiptRepository()
+  ).catch((err) => {
+    return err
+  })
+  if (announce instanceof Error) {
+    logger.error(`Namespace Announce ${announce}`)
+    return
+  }
+
+  logger.info('End Transaction')
+  logger.info(`${mijinUrl}/transactionStatus/${signedTransaction.hash}`)
+  logger.info(`${mijinUrl}/transactions/confirmed/${signedTransaction.hash}`)
+}

package/src/service/NamespaceServices.ts

@@ -0,0 +1,145 @@
+import {
+  UInt64,
+  NamespaceRegistrationTransaction,
+  Deadline,
+  NetworkType,
+  NamespaceId,
+  NamespaceRepository,
+  NamespaceInfo,
+  AliasAction,
+  AliasTransaction,
+  MosaicId,
+  Address,
+} from '@tech-bureau/symbol-sdk'
+import { firstValueFrom } from 'rxjs'
+
+export default class NamespaceServices {
+  constructor() {}
+
+  static createRootNamespace(
+    epoch: number,
+    name: string,
+    duration: number,
+    networkType: NetworkType,
+    feeMultiplier: number
+  ) {
+    // check name
+    const namespace = this.getNamespaceId(name)
+    if (!namespace) {
+      return null
+    }
+    return NamespaceRegistrationTransaction.createRootNamespace(
+      Deadline.create(epoch),
+      name,
+      UInt64.fromUint(duration),
+      networkType
+    ).setMaxFee(feeMultiplier)
+  }
+
+  static createSubNamespace(
+    epoch: number,
+    name: string,
+    parentName: string,
+    networkType: NetworkType,
+    feeMultiplier: number
+  ) {
+    // check name and parent name
+    const namespace = this.getNamespaceId(name)
+    if (!namespace) {
+      return null
+    }
+    const parentNamespace = this.getNamespaceId(parentName)
+    if (!parentNamespace) {
+      return null
+    }
+    return NamespaceRegistrationTransaction.createSubNamespace(
+      Deadline.create(epoch),
+      name,
+      parentName,
+      networkType
+    ).setMaxFee(feeMultiplier)
+  }
+
+  static linkMosaic(
+    epoch: number,
+    namespaceId: string,
+    mosaicId: string,
+    networkType: NetworkType,
+    feeMultiplier: number
+  ) {
+    const namespace = this.getNamespaceId(namespaceId)
+    if (!namespace) {
+      return null
+    }
+    let mosaic: MosaicId | null = null
+    try {
+      mosaic = new MosaicId(mosaicId)
+    } catch {}
+    if (!mosaic) {
+      return null
+    }
+    const mosaicAliasTransaction = AliasTransaction.createForMosaic(
+      Deadline.create(epoch),
+      AliasAction.Link,
+      namespace,
+      mosaic,
+      networkType
+    ).setMaxFee(feeMultiplier) as AliasTransaction
+    return mosaicAliasTransaction
+  }
+
+  static linkAddress(
+    epoch: number,
+    namespaceId: string,
+    address: string,
+    networkType: NetworkType,
+    feeMultiplier: number
+  ) {
+    const namespace = this.getNamespaceId(namespaceId)
+    if (!namespace) {
+      return null
+    }
+    if (!Address.isValidRawAddress(address)) {
+      return null
+    }
+    const addressObj = Address.createFromRawAddress(address)
+    const addressAliasTransaction = AliasTransaction.createForAddress(
+      Deadline.create(epoch),
+      AliasAction.Link,
+      namespace,
+      addressObj,
+      networkType
+    ).setMaxFee(feeMultiplier)
+    return addressAliasTransaction
+  }
+
+  static getNamespaceId(id: string) {
+    let namespaceId: NamespaceId | null = null
+    try {
+      namespaceId = new NamespaceId(id)
+    } catch {}
+    try {
+      namespaceId = NamespaceId.createFromEncoded(id)
+    } catch {}
+    return namespaceId
+  }
+
+  static async getNamespace(namespaceId: string, namespaceRepository: NamespaceRepository) {
+    const convertedNamespaceId = this.getNamespaceId(namespaceId)
+    if (!convertedNamespaceId) {
+      return null
+    }
+    const namespaceInfo = await firstValueFrom(namespaceRepository.getNamespace(convertedNamespaceId)).catch(() => null)
+    return namespaceInfo
+  }
+  static namespaceInfo(namespaceInfo: NamespaceInfo) {
+    return {
+      active: namespaceInfo.active,
+      ownerAddress: namespaceInfo.ownerAddress.plain(),
+      namespaceId: namespaceInfo.id.toHex(),
+      parentId: namespaceInfo.parentId.toHex(),
+      aliasMosaicId: namespaceInfo.alias.mosaicId?.toHex(),
+      aliasAddress: namespaceInfo.alias.address?.plain(),
+    }
+  }
+}

package/src/types/INamespaceOption.ts

@@ -0,0 +1,17 @@
+export interface INamespaceCreateOption {
+  owner: string
+  url?: string
+  name: string
+  duration?: number
+  parentName?: string
+  mosaicId?: string
+  address?: string
+  readfile?: string
+  privatekey?: string
+}
+
+export interface INamespaceInfoOption {
+  url?: string
+  readfile?: string
+  namespaceId?: string
+}

package/src/types/index.ts

@@ -7,3 +7,4 @@ export * from './ILinkOption'
 export * from './ConfigFile'
 export * from './IVotingOption'
 export * from './IMosaicOption'
+export * from './INamespaceOption'