@tech-bureau/mijin-catapult-tools 0.0.6

package/src/service/MosaicServices.ts

@@ -0,0 +1,62 @@
+import {
+  Currency,
+  Mosaic,
+  MosaicId,
+  UInt64,
+  MosaicNonce,
+  Address,
+  MosaicFlags,
+  MosaicRepository,
+  MosaicInfo,
+} from '@tech-bureau/symbol-sdk'
+import { Observable, firstValueFrom } from 'rxjs'
+
+export default class MosaicServices {
+  constructor() {}
+
+  static create(mosaicId: string, amount: number) {
+    return new Mosaic(new MosaicId(mosaicId), UInt64.fromUint(amount))
+  }
+
+  static createCurencyToAbsolute(currency: Currency, amount: number) {
+    return currency.createAbsolute(amount)
+  }
+
+  static createCurencyToRelative(currency: Currency, amount: number) {
+    return currency.createRelative(amount)
+  }
+
+  static createMosaicId(nonce: MosaicNonce, address: Address) {
+    return MosaicId.createFromNonce(nonce, address)
+  }
+
+  static createMosaicNonce() {
+    return MosaicNonce.createRandom()
+  }
+
+  static createMosaicFlags(
+    supplyMutable: boolean,
+    transferable: boolean,
+    restrictable?: boolean | undefined,
+    revokable?: boolean | undefined
+  ) {
+    return MosaicFlags.create(supplyMutable, transferable, restrictable, revokable)
+  }
+
+  static async getMosaic(mosaicId: string, mosaicRepository: MosaicRepository) {
+    try {
+      return await firstValueFrom(mosaicRepository.getMosaic(new MosaicId(mosaicId)))
+    } catch (error) {
+      throw new Error(`Mosaic Not Found`)
+    }
+  }
+
+  static mosaicInfo(mosaicInfo: MosaicInfo) {
+    return {
+      ownerAddress: mosaicInfo.ownerAddress.plain(),
+      mosaicId: mosaicInfo.id.toHex(),
+      supply: mosaicInfo.supply.compact(),
+      divisibility: mosaicInfo.divisibility,
+    }
+  }
+}

package/src/service/RepositoryFactory.ts

@@ -0,0 +1,107 @@
+import {
+  ChainInfo,
+  FinalizationProof,
+  NetworkConfiguration,
+  NetworkCurrencies,
+  NetworkType,
+  RepositoryFactoryHttp,
+  TransactionFees,
+} from '@tech-bureau/symbol-sdk'
+import { firstValueFrom } from 'rxjs'
+
+let networkType: NetworkType
+let currency: NetworkCurrencies
+let generationHash: string
+let epoch: number
+let repo: RepositoryFactoryHttp
+let tfees: TransactionFees
+let networkProperties: NetworkConfiguration
+let finalizationEpoch: number
+
+export default class RepositoryFactory {
+  constructor(public url: string) {}
+
+  async init() {
+    repo = new RepositoryFactoryHttp(this.url)
+    networkType = await firstValueFrom(repo.getNetworkType())
+    currency = await firstValueFrom(repo.getCurrencies())
+    generationHash = await firstValueFrom(repo.getGenerationHash())
+    epoch = await firstValueFrom(repo.getEpochAdjustment())
+    tfees = await firstValueFrom(repo.createNetworkRepository().getTransactionFees())
+    networkProperties = await firstValueFrom(this.createNetwork().getNetworkProperties())
+    finalizationEpoch = (await firstValueFrom(this.createChainRepository().getChainInfo())).latestFinalizedBlock
+      .finalizationEpoch
+  }
+
+  getNetwork() {
+    return networkType
+  }
+
+  getCurrency() {
+    return currency
+  }
+
+  getGnerationHash() {
+    return generationHash
+  }
+
+  getEpoch() {
+    return epoch
+  }
+
+  getEinalizationEpoch() {
+    return finalizationEpoch
+  }
+
+  getTransactionFees() {
+    return tfees
+  }
+
+  getNetworkProperties() {
+    return networkProperties
+  }
+
+  createNetwork() {
+    return repo.createNetworkRepository()
+  }
+
+  createLitener() {
+    return repo.createListener()
+  }
+
+  createTransactionRepository() {
+    return repo.createTransactionRepository()
+  }
+
+  createReceiptRepository() {
+    return repo.createReceiptRepository()
+  }
+
+  createAccountRepository() {
+    return repo.createAccountRepository()
+  }
+
+  createNamespaceRepository() {
+    return repo.createNamespaceRepository()
+  }
+
+  createMultisigRepository() {
+    return repo.createMultisigRepository()
+  }
+
+  createFinalizationRepository() {
+    return repo.createFinalizationRepository()
+  }
+
+  createBlockRepository() {
+    return repo.createBlockRepository()
+  }
+
+  createChainRepository() {
+    return repo.createChainRepository()
+  }
+
+  createMosaicRepository() {
+    return repo.createMosaicRepository()
+  }
+}

package/src/service/TransactionServices.ts

@@ -0,0 +1,268 @@
+import {
+  AggregateTransaction,
+  Deadline,
+  InnerTransaction,
+  NetworkType,
+  Account,
+  CosignatureTransaction,
+  TransactionAnnounceResponse,
+  TransactionHttp,
+  AccountKeyLinkTransaction,
+  LinkAction,
+  NodeKeyLinkTransaction,
+  VotingKeyLinkTransaction,
+  VrfKeyLinkTransaction,
+  HashLockTransaction,
+  Mosaic,
+  SignedTransaction,
+  UInt64,
+  MultisigAccountModificationTransaction,
+  Address,
+  Message,
+  TransferTransaction,
+  IListener,
+  ReceiptRepository,
+  TransactionRepository,
+  TransactionService,
+  MosaicDefinitionTransaction,
+  MosaicNonce,
+  MosaicId,
+  MosaicFlags,
+  MosaicSupplyChangeTransaction,
+  MosaicSupplyChangeAction,
+  TransactionGroup,
+  TransactionStatusHttp,
+  TransactionStatus,
+  Transaction,
+} from '@tech-bureau/symbol-sdk'
+import { ChronoUnit } from '@js-joda/core'
+import { firstValueFrom } from 'rxjs'
+import CreateAccount from './AccountServices'
+
+export default class TransactionServices {
+  constructor() {}
+
+  static async getTransactionStatus(url: string, transactionId: string): Promise<TransactionStatus> {
+    const transactionStatusHttp = new TransactionStatusHttp(url)
+    return await firstValueFrom(transactionStatusHttp.getTransactionStatus(transactionId))
+  }
+
+  static async getTransaction(url: string, transactionId: string, transactionStatus: string): Promise<Transaction> {
+    const transactionHttp = new TransactionHttp(url)
+    return await firstValueFrom(
+      transactionHttp.getTransaction(
+        transactionId,
+        transactionStatus === 'confirmed'
+          ? TransactionGroup.Confirmed
+          : transactionStatus === 'partial'
+          ? TransactionGroup.Partial
+          : TransactionGroup.Unconfirmed
+      )
+    )
+  }
+
+  static async announceCosign(
+    url: string,
+    account: Account,
+    transaction: AggregateTransaction
+  ): Promise<TransactionAnnounceResponse> {
+    const transactionHttp = new TransactionHttp(url)
+    const signdTransaction = account.signCosignatureTransaction(CosignatureTransaction.create(transaction))
+    return await firstValueFrom(transactionHttp.announceAggregateBondedCosignature(signdTransaction))
+  }
+
+  static async announceHashLockAggregateBonded(
+    signedHashLockTransaction: SignedTransaction,
+    signedTransaction: SignedTransaction,
+    listener: IListener,
+    transactionRepository: TransactionRepository,
+    receiptRepository: ReceiptRepository
+  ) {
+    const service = new TransactionService(transactionRepository, receiptRepository)
+
+    await listener.open()
+    const aggtx = await firstValueFrom(
+      service.announceHashLockAggregateBonded(signedHashLockTransaction, signedTransaction, listener)
+    ).catch((err) => {
+      listener.close()
+      throw new Error(err)
+    })
+    listener.close()
+    return aggtx
+  }
+
+  static async announce(
+    signedTransaction: SignedTransaction,
+    listener: IListener,
+    transactionRepository: TransactionRepository,
+    receiptRepository: ReceiptRepository
+  ) {
+    const service = new TransactionService(transactionRepository, receiptRepository)
+
+    await listener.open()
+    const tx = await firstValueFrom(service.announce(signedTransaction, listener)).catch((err) => {
+      listener.close()
+      throw new Error(err)
+    })
+    listener.close()
+    return tx
+  }
+
+  static createHashLock(
+    epoch: number,
+    mosaic: Mosaic,
+    signedTransaction: SignedTransaction,
+    networkType: NetworkType
+  ): HashLockTransaction {
+    return HashLockTransaction.create(
+      Deadline.create(epoch, 6, ChronoUnit.HOURS),
+      mosaic,
+      UInt64.fromUint(5760),
+      signedTransaction,
+      networkType
+    )
+  }
+
+  static createBonded(epoch: number, transactions: InnerTransaction[], networkType: NetworkType): AggregateTransaction {
+    return AggregateTransaction.createBonded(
+      Deadline.create(epoch, 24, ChronoUnit.HOURS),
+      transactions,
+      networkType,
+      []
+    )
+  }
+
+  static createComplete(
+    epoch: number,
+    transactions: InnerTransaction[],
+    networkType: NetworkType
+  ): AggregateTransaction {
+    return AggregateTransaction.createComplete(
+      Deadline.create(epoch, 24, ChronoUnit.HOURS),
+      transactions,
+      networkType,
+      []
+    )
+  }
+
+  static createVrfKey(epoch: number, linkPublickey: string, networkType: NetworkType): VrfKeyLinkTransaction {
+    return VrfKeyLinkTransaction.create(Deadline.create(epoch), linkPublickey, LinkAction.Link, networkType)
+  }
+
+  static createVotingKey(epoch: number, linkPublickey: string, networkType: NetworkType): VotingKeyLinkTransaction {
+    return VotingKeyLinkTransaction.create(
+      Deadline.create(epoch),
+      linkPublickey,
+      1,
+      360,
+      LinkAction.Link,
+      networkType,
+      1
+    )
+  }
+
+  static createAccountKey(epoch: number, linkPublickey: string, networkType: NetworkType): AccountKeyLinkTransaction {
+    return AccountKeyLinkTransaction.create(Deadline.create(epoch), linkPublickey, LinkAction.Link, networkType)
+  }
+
+  static createNodeKey(epoch: number, linkPublickey: string, networkType: NetworkType): NodeKeyLinkTransaction {
+    return NodeKeyLinkTransaction.create(Deadline.create(epoch), linkPublickey, LinkAction.Link, networkType)
+  }
+
+  static createMultisig(
+    epoch: number,
+    minApproval: number,
+    minRemoval: number,
+    addAddresses: string[] | [],
+    delAddresses: string[] | [],
+    networkType: NetworkType
+  ) {
+    const addressAdditions =
+      addAddresses.length > 0 ? CreateAccount.createPublicAccountArray(addAddresses, networkType) : []
+    const addressDeletions =
+      delAddresses.length > 0 ? CreateAccount.createPublicAccountArray(delAddresses, networkType) : []
+    return MultisigAccountModificationTransaction.create(
+      Deadline.create(epoch, 6, ChronoUnit.HOURS),
+      minApproval,
+      minRemoval,
+      addressAdditions,
+      addressDeletions,
+      networkType
+    )
+  }
+
+  static createTransfer(
+    epoch: number,
+    recipientAddress: Address,
+    mosaic: Mosaic[] | [],
+    message: Message,
+    networkType: NetworkType
+  ): TransferTransaction {
+    return TransferTransaction.create(
+      Deadline.create(epoch, 6, ChronoUnit.HOURS),
+      recipientAddress,
+      mosaic,
+      message,
+      networkType
+    )
+  }
+
+  static createMosaicDefinition(
+    epoch: number,
+    nonce: MosaicNonce,
+    mosaicId: MosaicId,
+    mosaicFlags: MosaicFlags,
+    divisibility: number,
+    networkType: NetworkType,
+    duration?: number | undefined
+  ): MosaicDefinitionTransaction {
+    return MosaicDefinitionTransaction.create(
+      Deadline.create(epoch),
+      nonce,
+      mosaicId,
+      mosaicFlags,
+      divisibility,
+      duration ? UInt64.fromUint(duration) : UInt64.fromUint(0),
+      networkType
+    )
+  }
+
+  static createMosaicSupplyChange(
+    epoch: number,
+    mosaicId: MosaicId,
+    mosaicSupply: number,
+    networkType: NetworkType
+  ): MosaicSupplyChangeTransaction {
+    return MosaicSupplyChangeTransaction.create(
+      Deadline.create(epoch),
+      mosaicId,
+      MosaicSupplyChangeAction.Increase,
+      UInt64.fromUint(mosaicSupply),
+      networkType
+    )
+  }
+
+  static deleteVrf(epoch: number, linkPublickey: string, networkType: NetworkType): VrfKeyLinkTransaction {
+    return VrfKeyLinkTransaction.create(Deadline.create(epoch), linkPublickey, LinkAction.Unlink, networkType)
+  }
+
+  static deleteVoting(epoch: number, linkPublickey: string, networkType: NetworkType): VotingKeyLinkTransaction {
+    return VotingKeyLinkTransaction.create(
+      Deadline.create(epoch),
+      linkPublickey,
+      1,
+      26280,
+      LinkAction.Unlink,
+      networkType,
+      1
+    )
+  }
+
+  static deleteAccount(epoch: number, linkPublickey: string, networkType: NetworkType): AccountKeyLinkTransaction {
+    return AccountKeyLinkTransaction.create(Deadline.create(epoch), linkPublickey, LinkAction.Unlink, networkType)
+  }
+
+  static deleteNode(epoch: number, linkPublickey: string, networkType: NetworkType): NodeKeyLinkTransaction {
+    return NodeKeyLinkTransaction.create(Deadline.create(epoch), linkPublickey, LinkAction.Unlink, networkType)
+  }
+}

package/src/service/VotingServices.ts

@@ -0,0 +1,184 @@
+/*
+ * Copyright 2022 Fernando Boucquez
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as noble from '@noble/ed25519'
+import { existsSync, lstatSync, readdirSync, readFileSync } from 'fs'
+import { join } from 'path'
+import { Convert, Crypto } from '@tech-bureau/symbol-sdk'
+import * as nacl from 'tweetnacl'
+
+export interface KeyPair {
+  privateKey: Uint8Array
+  publicKey: Uint8Array
+}
+export interface CryptoImplementation {
+  name: string
+  createKeyPairFromPrivateKey: (privateKey: Uint8Array) => Promise<KeyPair>
+  sign: (keyPair: KeyPair, data: Uint8Array) => Promise<Uint8Array>
+}
+
+export interface VotingKeyAccount {
+  readonly startEpoch: number
+  readonly endEpoch: number
+  readonly publicKey: string
+}
+
+export type VotingKeyFile = VotingKeyAccount & { filename: string }
+
+export class VotingUtils {
+  public static nobleImplementation: CryptoImplementation = {
+    name: 'Noble',
+    createKeyPairFromPrivateKey: async (privateKey: Uint8Array): Promise<KeyPair> => {
+      const publicKey = await noble.getPublicKey(privateKey)
+      return { privateKey, publicKey: publicKey }
+    },
+    sign: async (keyPair: KeyPair, data: Uint8Array): Promise<Uint8Array> => {
+      return await noble.sign(data, keyPair.privateKey)
+    },
+  }
+
+  public static tweetNaClImplementation: CryptoImplementation = {
+    name: 'TweetNaCl',
+    createKeyPairFromPrivateKey: async (privateKey: Uint8Array): Promise<KeyPair> => {
+      const { publicKey } = nacl.sign.keyPair.fromSeed(privateKey)
+      return { privateKey, publicKey }
+    },
+
+    sign: async (keyPair: KeyPair, data: Uint8Array): Promise<Uint8Array> => {
+      const secretKey = new Uint8Array(64)
+      secretKey.set(keyPair.privateKey)
+      secretKey.set(keyPair.publicKey, 32)
+      return nacl.sign.detached(data, secretKey)
+    },
+  }
+
+  public static implementations = [VotingUtils.nobleImplementation, VotingUtils.tweetNaClImplementation]
+
+  constructor(private readonly implementation: CryptoImplementation = VotingUtils.nobleImplementation) {}
+  public insert(result: Uint8Array, value: Uint8Array, index: number): number {
+    result.set(value, index)
+    return index + value.length
+  }
+
+  public async createVotingFile(
+    secret: string,
+    votingKeyStartEpoch: number,
+    votingKeyEndEpoch: number,
+    unitTestPrivateKeys: Uint8Array[] | undefined = undefined
+  ): Promise<Uint8Array> {
+    const items = votingKeyEndEpoch - votingKeyStartEpoch + 1
+    const headerSize = 64 + 16
+    const itemSize = 32 + 64
+    const totalSize = headerSize + items * itemSize
+    const rootPrivateKey = await this.implementation.createKeyPairFromPrivateKey(Convert.hexToUint8(secret))
+    const result = new Uint8Array(totalSize)
+    //start-epoch (8b),
+    let index = 0
+    index = this.insert(result, Convert.numberToUint8Array(votingKeyStartEpoch, 8), index)
+
+    //end-epoch (8b),
+    index = this.insert(result, Convert.numberToUint8Array(votingKeyEndEpoch, 8), index)
+
+    // could it have other values????
+    //last key identifier (8b) - for fresh file this is 0xFFFF'FFFF'FFFF'FFFF (a.k.a. Invalid_Id)
+    index = this.insert(result, Convert.hexToUint8('FFFFFFFFFFFFFFFF'), index)
+
+    //last wipe key identifier (8b) - again, for fresh file this is 0xFFFF'FFFF'FFFF'FFFF (Invalid_Id)
+    index = this.insert(result, Convert.hexToUint8('FFFFFFFFFFFFFFFF'), index)
+
+    // root public key (32b) - this is root public key that is getting announced via vote link tx
+    index = this.insert(result, rootPrivateKey.publicKey, index)
+    // start-epoch (8b), \ those two are exactly same one, as top level, reason is this was earlier a tree,
+    index = this.insert(result, Convert.numberToUint8Array(votingKeyStartEpoch, 8), index)
+
+    //end-epoch (8b), / and each level holds this separately, so we left it as is
+    index = this.insert(result, Convert.numberToUint8Array(votingKeyEndEpoch, 8), index)
+    /// what follows are bound keys, there are (end - start + 1) of them.
+
+    // each key is:
+    for (let i = 0; i < items; i++) {
+      // random PRIVATE key (32b)
+      const randomPrivateKey = unitTestPrivateKeys ? unitTestPrivateKeys[i] : Crypto.randomBytes(32)
+      if (randomPrivateKey.length != 32) {
+        throw new Error(`Invalid private key size ${randomPrivateKey.length}!`)
+      }
+      const randomKeyPar = await this.implementation.createKeyPairFromPrivateKey(randomPrivateKey)
+      index = this.insert(result, randomPrivateKey, index)
+      // signature (64b)
+      // now the signature is usual signature done using ROOT private key on a following data:
+      //   (public key (32b), identifier (8b))
+      //
+      //   identifier is simply epoch, but, most importantly keys are written in REVERSE order.
+      //
+      //   i.e. say your start-epoch = 2, end-epoch = 42
+      const identifier = Convert.numberToUint8Array(votingKeyEndEpoch - i, 8)
+      const signature = await this.implementation.sign(
+        rootPrivateKey,
+        Uint8Array.from([...randomKeyPar.publicKey, ...identifier])
+      )
+      index = this.insert(result, signature, index)
+    }
+    //
+    // root private key is discarded after file is created.
+    // header:
+    //   2, 42, ff.., ff..., (root pub), 2, 42
+    // keys:
+    //   (priv key 42, sig 42), (priv key 41, sig 31), ..., (priv key 2, sig 2)
+    //
+    // every priv key should be cryptographically random,
+
+    return result
+  }
+
+  public readVotingFile(file: Uint8Array): VotingKeyAccount {
+    //start-epoch (8b),
+    const votingKeyStartEpoch = Convert.uintArray8ToNumber(file.slice(0, 8))
+    //end-epoch (8b),
+    const votingKeyEndEpoch = Convert.uintArray8ToNumber(file.slice(8, 16))
+    const votingPublicKey = Convert.uint8ToHex(file.slice(32, 64))
+
+    const items = votingKeyEndEpoch - votingKeyStartEpoch + 1
+    const headerSize = 64 + 16
+    const itemSize = 32 + 64
+    const totalSize = headerSize + items * itemSize
+
+    if (file.length != totalSize) {
+      throw new Error(`Unexpected voting key file. Expected ${totalSize} but got ${file.length}`)
+    }
+    return {
+      publicKey: votingPublicKey,
+      startEpoch: votingKeyStartEpoch,
+      endEpoch: votingKeyEndEpoch,
+    }
+  }
+
+  public loadVotingFiles(folder: string): VotingKeyFile[] {
+    if (!existsSync(folder)) {
+      return []
+    }
+    return readdirSync(folder)
+      .map((filename: string) => {
+        const currentPath = join(folder, filename)
+        if (lstatSync(currentPath).isFile() && filename.startsWith('private_key_tree') && filename.endsWith('.dat')) {
+          return { ...this.readVotingFile(readFileSync(currentPath)), filename }
+        } else {
+          return undefined
+        }
+      })
+      .filter((i) => i)
+      .map((i) => i as VotingKeyFile)
+      .sort((a, b) => a.startEpoch - b.startEpoch)
+  }
+}

package/src/types/AccountInfo.ts

@@ -0,0 +1,19 @@
+export interface AccountInfo {
+  url: string,
+  network: string,
+  account: string,
+  address: string,
+  mosaics: mosaics[],
+  linkedKeys: {
+    linked: string,
+      node: string,
+      vrf: string,
+      voting: string
+  }
+}
+
+interface mosaics {
+  mosaic: string;
+  amount: string;
+  namespaceAlias: string;
+}[]

package/src/types/AccountType.ts

@@ -0,0 +1,9 @@
+export enum AccountType {
+  work = 'workAccount',
+  balance = 'balanceAccount',
+  main = 'mainAccount',
+  test1 = 'test1Account',
+  test2 = 'test2Account',
+  voting = 'votingAccount',
+  vrf = 'vrfAccount',
+}

package/src/types/ConfigFile.ts

@@ -0,0 +1,24 @@
+export interface ConfigFile {
+  url: string
+  workAccount: ConfigAccount
+  balanceAccount: ConfigAccount
+  mainAccount: ConfigAccount
+  keylink: {
+    vrf: ConfigAccount
+    voting: ConfigAccount
+  }
+  multisig?: {
+    minApproval?: number
+    minRemoval?: number
+    addCosigner?: ConfigAccount[]
+    delCosigner?: ConfigAccount[]
+  }
+  test1Account: ConfigAccount
+  test2Account: ConfigAccount
+}
+
+interface ConfigAccount {
+  publicKey: string
+  privateKey: string
+  address: string
+}

package/src/types/Environment.ts

@@ -0,0 +1,5 @@
+export enum Environment {
+  'dev' = 'dev',
+  'test' = 'test',
+  'prod' = 'prod',
+}

package/src/types/IAccountOption.ts

@@ -0,0 +1,16 @@
+export interface IAccountGenerateOption {
+  url?: string
+  nodename?: string
+  readfile?: string
+  writefile?: string
+  certsdir?: string
+  privatekey?: string
+  service: boolean
+}
+
+export interface IAccountInfoOption {
+  type?: string
+  url?: string
+  readfile?: string
+  address?: string
+}

package/src/types/ILinkOption.ts

@@ -0,0 +1,3 @@
+export interface ILinkOption {
+  publicKey: string
+}