rename classes and cleanup

Author: billbsing

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Beta Testing
 
+### Release v0.1.4
++   Rename ConvexAccount to Account
++   Rename ConvexAPI to API
++   Split ConvexAccount to KeyPair
+
 ### Relase 0.1.3
 +   Add address '#' identifier before each address number.
 

src/ConvexAPI.ts src/API.tssrc/ConvexAPI.ts renamed to src/API.ts

@@ -0,0 +1,40 @@
+/*
+
+    Account.ts class to manage address and name.
+
+*/
+
+import { KeyPair } from 'KeyPair'
+
+export class Account {
+    readonly keyPair: KeyPair // KeyPair object
+    readonly address: BigInt // address for this account
+    readonly name: string // name of the registered account
+
+    constructor(keyPair: KeyPair, address: BigInt, name: string) {
+        this.keyPair = keyPair
+        this.address = address
+        this.name = name
+    }
+
+    /**
+     * Creates a new account
+     *
+     * @returns a new Account Object
+     */
+    public static create(keyPair: KeyPair, address?: BigInt, name?: string): Account {
+        return new Account(keyPair, address, name);
+    }
+
+    /**
+     * Sign text, and return the signature
+     *
+     * @param text Text to sign
+     *
+     * @returns a signature of the signed text
+     *
+     */
+    public sign(text: string): string {
+        return this.keyPair.sign(text);
+    }
+}

src/Account.ts

@@ -2,11 +2,11 @@
 
 
 
-    ConvexAPI Errors
+    Convex Errors
 
 */
 
-class ConvexAPIBaseError extends Error {
+class APIBaseError extends Error {
     readonly source: string
     readonly code: string
     readonly text: string
@@ -20,13 +20,13 @@ class ConvexAPIBaseError extends Error {
     }
 }
 
-export class ConvexAPIError extends ConvexAPIBaseError {
+export class APIError extends APIBaseError {
     constructor(source: string, code: string, text: string) {
         super(source, code, text, 'ConvexAPIError')
     }
 }
 
-export class ConvexAPIRequestError extends ConvexAPIBaseError {
+export class APIRequestError extends APIBaseError {
     constructor(source: string, code: string, text: string) {
         super(source, code, text, 'ConvexAPIRequestError')
     }

src/Errors.ts

@@ -3,7 +3,7 @@
 
 */
 
-export interface IConvexAccountInformation {
+export interface IAccountInformation {
     address: BigInt
     isLibrary: boolean
     isActor: boolean

src/Interfaces.ts

@@ -1,6 +1,6 @@
 /*
 
-    ConvexAccount.ts class to manage private/public key for signing hashed text on the Convex Network.
+    KeyPair.ts class to manage private/public key for signing hashed text on the Convex Network.
 
 
 */
@@ -11,20 +11,29 @@ import pem from 'pem-file'
 
 import { toPublicKeyChecksum } from './Utils'
 
-export class ConvexAccount {
+export class KeyPair {
     readonly privateKey: KeyObject // private key object
     readonly publicKey: KeyObject // public key object
-    readonly address: BigInt // address for this account
-    readonly name: string // name of the registered account
     readonly publicKeyAPI: string // address as hex string without leading '0x'
     readonly publicKeyChecksum: string // address as hex string with checksum upper an lower case hex letters
 
+    constructor(publicKey: KeyObject, privateKey: KeyObject) {
+        this.publicKey = publicKey
+        this.privateKey = privateKey
+        const exportPublicKey = publicKey.export({
+            type: 'spki',
+            format: 'pem',
+        })
+        this.publicKeyAPI = pem.decode(exportPublicKey).toString('hex').substring(24)
+        this.publicKeyChecksum = toPublicKeyChecksum(this.publicKeyAPI)
+    }
+
     /**
-     * Creates a new account
+     * Creates a new keypair
      *
-     * @returns a new ConvexAccount Object
+     * @returns a new KeyPair Object
      */
-    public static create(): ConvexAccount {
+    public static create(): KeyPair {
         // create a temporary password for generating a random private/public keys
         const password = randomBytes(64).toString('hex')
         const { publicKey, privateKey } = generateKeyPairSync('ed25519', {
@@ -39,29 +48,26 @@ export class ConvexAccount {
                 passphrase: password,
             },
         })
-        return ConvexAccount.importFromString(privateKey, password, null, null, publicKey)
+        return KeyPair.importFromString(privateKey, password, publicKey)
     }
 
     /**
-     * Imports an account from a PKCS8 fromated text string. You need to pass the correct password, to decrypt
+     * Imports a keypair from a PKCS8 fromated text string. You need to pass the correct password, to decrypt
      * the private key stored in the text string.
      *
      * @param text PKCS8 fromated text with the private key encrypted.
      * @param password Password to decrypt the private key.
-     * @param address Optional address used for this account.
      * @param publicKeyText Optional public key encoded in PEM format, if non provided, the public key
      * can be obtained from the private key.
      *
-     * @returns an account object with the private and public key pairs.
+     * @returns an KeyPair object with the private and public key pairs.
      *
      */
     public static importFromString(
         text: string,
         password: string,
-        address?: BigInt,
-        name?: string,
         publicKeyText?: string
-    ): ConvexAccount {
+    ): KeyPair {
         const privateKey = createPrivateKey({
             key: text,
             type: 'pkcs8',
@@ -75,60 +81,38 @@ export class ConvexAccount {
             publicKey = createPublicKey(privateKey)
         }
 
-        return new ConvexAccount(publicKey, privateKey, address, name)
+        return new KeyPair(publicKey, privateKey)
     }
 
     /**
      * Imports a private key file. The key file is in the format as PKCS8 text. The private key is encrypted.
      *
      * @param filename Filename containing the encrypted private key.
      * @param password Password to decrypt the private key.
-     * @param address Optional address used for this account.
      *
-     * @returns An ConvexAccount object with the private and public keys.
+     * @returns An KeyPair object with the private and public keys.
      *
      */
     public static async importFromFile(
         filename: string,
         password: string,
-        address?: BigInt,
-        name?: string
-    ): Promise<ConvexAccount> {
+    ): Promise<KeyPair> {
         if (fs.existsSync(filename)) {
             const data = await fs.promises.readFile(filename)
-            return ConvexAccount.importFromString(data.toString(), password, address, name)
+            return KeyPair.importFromString(data.toString(), password)
         }
         return null
     }
 
-    public static async importFromAccount(account: ConvexAccount, address?: BigInt, name?: string): Promise<ConvexAccount> {
-        const password = randomBytes(64).toString('hex')
-        const keyText = account.exportToText(password)
-        return ConvexAccount.importFromString(keyText, password, address, name)
-    }
-
-    constructor(publicKey: KeyObject, privateKey: KeyObject, address?: BigInt, name?: string) {
-        this.publicKey = publicKey
-        this.privateKey = privateKey
-        const exportPublicKey = publicKey.export({
-            type: 'spki',
-            format: 'pem',
-        })
-        this.publicKeyAPI = pem.decode(exportPublicKey).toString('hex').substring(24)
-        this.publicKeyChecksum = toPublicKeyChecksum(this.publicKeyAPI)
-        this.address = address
-        this.name = name
-    }
-
     /**
-     * Export the account to a PKCS8 fromatted text string. The private key is encrypted using the provided password.
+     * Export the keypair to a PKCS8 fromatted text string. The private key is encrypted using the provided password.
      *
      * @param password Password to encrypt the private key.
      *
      * @returns The encrpted private key as a PKCS8 formatted string.
      *
      */
-    public exportToText(password: string): string {
+    public exportToString(password: string): string {
         return this.privateKey
             .export({
                 type: 'pkcs8',
@@ -146,12 +130,12 @@ export class ConvexAccount {
      *
      */
     public async exportToFile(filename: string, password: string): Promise<unknown> {
-        return await fs.promises.writeFile(filename, this.exportToText(password))
+        return await fs.promises.writeFile(filename, this.exportToString(password))
     }
 
     /**
      * Sign a hash message. This is called by the convex API class to sign a hash returned from the `prepare` api.
-     * This signed message cryptographically proves that the account owner has access to the private key.
+     * This signed message cryptographically proves that the keypair owner has access to the private key.
      *
      * The API calls this with a hex string, that is converted to bytes, and then sigend.
      * The resultant signed data is sent back as a hex string.

src/ConvexAccount.ts src/KeyPair.tssrc/ConvexAccount.ts renamed to src/KeyPair.ts

@@ -6,28 +6,28 @@
 
 */
 
-import { ConvexAccount } from './ConvexAccount'
-import { ConvexAPI } from './ConvexAPI'
+import { Account } from './Account'
+import { API } from './API'
 import { toAddress } from './Utils'
 import { IRegistryItem } from './Interfaces'
 
 const QUERY_ACCOUNT_ADDRESS = BigInt(9)
 
 export class Registry {
     /**
-     * Convex API object to call registry commands
+     * Registry object to call registry commands
      */
-    readonly convex: ConvexAPI
+    readonly convex: API
     address: BigInt
     protected items: { [name: string]: IRegistryItem } = {}
 
     /**
      * Initaliizes a new Registry object, you need to provide a ConvexAPI Object.
      *
-     * @param convex ConvexAPI object to access the convex network.
+     * @param convex API object to access the convex network.
      *
      */
-    public constructor(convex: ConvexAPI) {
+    public constructor(convex: API) {
         this.convex = convex
     }
 
@@ -85,7 +85,7 @@ export class Registry {
      * @returns an IRegistryItem object with the new address and owner address of the registered item.
      *
      */
-    public async register(name: string, registerAddress: BigInt, account: ConvexAccount): Promise<IRegistryItem> {
+    public async register(name: string, registerAddress: BigInt, account: Account): Promise<IRegistryItem> {
         const address = await this.getAddress()
         const registerLine = `(call #${address} (register {:name "${name}"}))`
         const registerResult = await this.convex.send(registerLine, account)

src/Registry.ts

@@ -6,7 +6,8 @@
  *
  */
 
-export { ConvexAccount } from './ConvexAccount'
-export { ConvexAPI } from './ConvexAPI'
-export { ConvexAPIRequestError, ConvexAPIError } from './Errors'
-export { IConvexAccountInformation } from './Interfaces'
+export { Account } from './Account'
+export { API } from './API'
+export { APIRequestError, APIError } from './Errors'
+export { IAccountInformation } from './Interfaces'
+export { KeyPair } from './KeyPair'