refactor: intialize registrar client with keypair type

Author: SalmaElsoly

packages/registrar_client/README.md

@@ -35,7 +35,22 @@ This package provides a client for interacting with the TFGrid v4 Node Registrar
 
 ## Getting Started
 
-To initialize the Registrar Client, you need to provide the base url of registrar and your mnemonics or 64 character hex seed
+To initialize the Registrar Client, you need to provide the base URL of the registrar and either your mnemonic phrase or a 64-character hex seed. You also need to specify the keypair type.
+
+The supported keypair types are:
+
+- `ed25519`
+- `sr25519` (default)
+
+Here's how to initialize the client:
+
+```typescript
+const client = new RegistrarClient({
+  baseUrl: "https://registrar.dev4.grid.tf/v1",
+  mnemonicOrSeed: "your_mnemonic_or_seed",
+  keypairType: "sr25519", // Optional, defaults to "sr25519"
+});
+```
 
 To generate 64 character hex seed:
 
@@ -46,7 +61,11 @@ openssl rand -hex 32
 Here is an example:
 
 ```typescript
-const client = new RegistrarClient({ baseURl: "https://registrar.dev4.grid.tf/v1", mnemonicOrSeed: "your_mnemonic_or_seed" });
+const client = new RegistrarClient({
+  baseURl: "https://registrar.dev4.grid.tf/v1",
+  mnemonicOrSeed: "your_mnemonic_or_seed",
+  keypairType: "ed21559"
+});
 ```
 
 To be able to create a farm you need to have a Stellar wallet and provide your Stellar address. For more details on how to create a Stellar wallet and generate a Stellar address, please refer to the [Stellar Account Viewer](https://www.stellar.org/account-viewer/#!/) or the [Stellar Documentation](https://developers.stellar.org/docs/tutorials/create-account/).
@@ -56,7 +75,7 @@ To be able to create a farm you need to have a Stellar wallet and provide your S
 Here is an example of how to use the Registrar Client:
 
 ```typescript
-const client = new RegistrarClient({ baseUrl: URl, mnemonicOrSeed: your_mnemonic_or_seed });
+const client = new RegistrarClient({ baseUrl: URl, mnemonicOrSeed: your_mnemonic_or_seed, keypairType: "ed21559" });
 
 // Example: Create an account
 const accountRequest: CreateAccountRequest = {

packages/registrar_client/scripts/README.md

@@ -16,12 +16,12 @@ yarn install
 
 ## Getting Started
 
-- Set base URL, your mnemonic or seed, and Stellar address (if needed) in `scripts/config.json`.
+- Set base URL, your mnemonic or seed, keypair type and Stellar address (if needed) in `scripts/config.json`.
 
 ## Usage
 
 To run any of the scripts, use the following command format:
 
 ```bash
-yarn ts-node --project tsconfig-node.json scripts/<script_name>.ts 
+yarn ts-node --project tsconfig-node.json scripts/<script_name>.ts
 ```

packages/registrar_client/scripts/config.json

@@ -1 +1 @@
-{"baseUrl": "https://registrar.dev4.grid.tf/v1", "mnemonicOrSeed": "", "stellarAddress": ""}
+{"baseUrl": "https://registrar.dev4.grid.tf/v1", "mnemonicOrSeed": "", "stellarAddress": "", "keypairType": "ed25519"}

packages/registrar_client/scripts/create_account.ts

@@ -1,6 +1,7 @@
 import { log } from "console";
 import { RegistrarClient } from "../src/";
 import config from "./config.json";
+import { KeypairType } from "@polkadot/util-crypto/types";
 
 async function createAccount(client: RegistrarClient) {
   const account = await client.accounts.createAccount({});
@@ -10,7 +11,7 @@ async function createAccount(client: RegistrarClient) {
 }
 
 async function main() {
-  const client = new RegistrarClient({ baseURL: config.baseUrl, mnemonicOrSeed: config.mnemonicOrSeed });
+  const client = new RegistrarClient({ baseURL: config.baseUrl, mnemonicOrSeed: config.mnemonicOrSeed, keypairType: config.keypairType as KeypairType });
   await createAccount(client);
 }
 

packages/registrar_client/scripts/create_farm.ts

@@ -3,9 +3,10 @@ import { Account, RegistrarClient } from "../src/";
 import config from "./config.json";
 import * as base64 from "base64-js";
 import { deriveKeyPair } from "../src/utils";
+import { KeypairType } from "@polkadot/util-crypto/types";
 
 async function getAccount(client: RegistrarClient): Promise<Account> {
-  const keyPair = await deriveKeyPair(config.mnemonicOrSeed);
+  const keyPair = await deriveKeyPair(config.mnemonicOrSeed, config.keypairType as KeypairType);
   const account = await client.accounts.getAccountByPublicKey(base64.fromByteArray(keyPair.publicKey));
   log("================= Getting Account =================");
   log(account);

packages/registrar_client/scripts/create_node.ts

@@ -3,9 +3,10 @@ import { Account, RegistrarClient, NodeRegistrationRequest } from "../src/";
 import config from "./config.json";
 import * as base64 from "base64-js";
 import { deriveKeyPair } from "../src/utils";
+import { KeypairType } from "@polkadot/util-crypto/types";
 
 async function getAccount(client: RegistrarClient): Promise<Account> {
-  const keyPair = await deriveKeyPair(config.mnemonicOrSeed);
+  const keyPair = await deriveKeyPair(config.mnemonicOrSeed, config.keypairType as KeypairType);
   const account = await client.accounts.getAccountByPublicKey(base64.fromByteArray(keyPair.publicKey));
   log("================= Getting Account =================");
   log(account);
@@ -29,7 +30,7 @@ async function getNode(client: RegistrarClient, nodeID: number) {
 }
 
 async function main() {
-  const client = new RegistrarClient({ baseURL: config.baseUrl, mnemonicOrSeed: config.mnemonicOrSeed });
+  const client = new RegistrarClient({ baseURL: config.baseUrl, mnemonicOrSeed: config.mnemonicOrSeed, keypairType: config.keypairType as KeypairType });
   const account = await getAccount(client);
   const twinID = account.twin_id;
   const node: NodeRegistrationRequest = {

packages/registrar_client/scripts/update_account.ts

@@ -1,6 +1,7 @@
 import { log } from "console";
 import { RegistrarClient, UpdateAccountRequest } from "../src/";
 import config from "./config.json";
+import { KeypairType } from "@polkadot/util-crypto/types";
 
 async function updateAccount(client: RegistrarClient, twinID: number, update: UpdateAccountRequest) {
   const account = await client.accounts.updateAccount(twinID, update);
@@ -17,7 +18,7 @@ async function getAccount(client: RegistrarClient, twinID: number) {
 }
 
 async function main() {
-  const client = new RegistrarClient({ baseURL: config.baseUrl, mnemonicOrSeed: config.mnemonicOrSeed });
+  const client = new RegistrarClient({ baseURL: config.baseUrl, mnemonicOrSeed: config.mnemonicOrSeed, keypairType: config.keypairType as KeypairType });
   const update: UpdateAccountRequest = {
     relays: ["relay1", "relay2"],
     rmb_enc_key: "rmb_enc_key",

packages/registrar_client/scripts/update_farm.ts

@@ -1,6 +1,7 @@
 import { log } from "console";
 import { RegistrarClient } from "../src/";
 import config from "./config.json";
+import { KeypairType } from "@polkadot/util-crypto/types";
 
 async function updateFarm(client: RegistrarClient, twinID: number, farmID: number, farmName: string) {
   const farm = await client.farms.updateFarm(farmID, twinID, farmName, config.stellarAddress);
@@ -17,7 +18,7 @@ async function getFarm(client: RegistrarClient, farmID: number) {
 }
 
 async function main() {
-  const client = new RegistrarClient({ baseURL: config.baseUrl, mnemonicOrSeed: config.mnemonicOrSeed });
+  const client = new RegistrarClient({ baseURL: config.baseUrl, mnemonicOrSeed: config.mnemonicOrSeed, keypairType: config.keypairType as KeypairType });
   const twinID = 143;
   const farmID = 46;
   const farmName = "testfarm";

packages/registrar_client/scripts/update_node.ts

@@ -1,6 +1,7 @@
 import { log } from "console";
 import { UpdateNodeRequest, RegistrarClient } from "../src/";
 import config from "./config.json";
+import { KeypairType } from "@polkadot/util-crypto/types";
 
 async function updateNode(client: RegistrarClient, twinID: number, nodeID: number, update: UpdateNodeRequest) {
   const account = await client.nodes.updateNode(nodeID, twinID, update);
@@ -17,7 +18,7 @@ async function getNode(client: RegistrarClient, nodeID: number) {
 }
 
 async function main() {
-  const client = new RegistrarClient({ baseURL: config.baseUrl, mnemonicOrSeed: config.mnemonicOrSeed });
+  const client = new RegistrarClient({ baseURL: config.baseUrl, mnemonicOrSeed: config.mnemonicOrSeed, keypairType: config.keypairType as KeypairType });
   const update: UpdateNodeRequest = {
     farm_id: 46,
     interfaces: [

packages/registrar_client/src/client/client.ts

@@ -3,7 +3,9 @@ import { Accounts } from "../modules/accounts";
 import { Farms } from "../modules/farms";
 import { Nodes } from "../modules/nodes";
 import { Zos } from "../modules/zos";
-import {validateMnemonic} from "bip39";
+import { validateMnemonic } from "bip39";
+import { KeypairType } from "@polkadot/util-crypto/types";
+import { SUPPORTED_KEYPAIR_TYPES } from "../utils";
 export abstract class BaseClient {
   private client: AxiosInstance;
 
@@ -36,10 +38,12 @@ export abstract class BaseClient {
 interface Config {
   baseURL: string;
   mnemonicOrSeed: string;
+  keypairType?: KeypairType;
 }
 
 export class RegistrarClient extends BaseClient {
   public readonly mnemonicOrSeed: string;
+  public readonly keypairType: KeypairType;
   accounts: Accounts;
   farms: Farms;
   nodes: Nodes;
@@ -55,7 +59,10 @@ export class RegistrarClient extends BaseClient {
     return seed;
   }
 
-  constructor({ baseURL, mnemonicOrSeed }: Config) {
+  constructor({ baseURL, mnemonicOrSeed, keypairType = "sr25519" }: Config) {
+    if (!SUPPORTED_KEYPAIR_TYPES.includes(keypairType)) {
+      throw new Error(`Unsupported keypair type: ${keypairType}`);
+    }
     if (!baseURL) {
       throw new Error("Base URL is required");
     }
@@ -69,6 +76,7 @@ export class RegistrarClient extends BaseClient {
     }
 
     this.mnemonicOrSeed = mnemonicOrSeed;
+    this.keypairType = keypairType;
     this.accounts = new Accounts(this);
     this.farms = new Farms(this);
     this.nodes = new Nodes(this);

packages/registrar_client/src/modules/accounts.ts

@@ -12,7 +12,7 @@ export class Accounts {
   }
 
   async createAccount(request: Partial<CreateAccountRequest>): Promise<Account | null> {
-    const { signature, publicKey, timestamp } = await createSignatureWithPublicKey(this.client.mnemonicOrSeed);
+    const { signature, publicKey, timestamp } = await createSignatureWithPublicKey(this.client.mnemonicOrSeed, this.client.keypairType);
 
     request.public_key = publicKey;
     request.signature = signature;
@@ -53,7 +53,7 @@ export class Accounts {
 
   async updateAccount(twinID: number, body: UpdateAccountRequest): Promise<any> {
     try {
-      const headers = await createAuthHeader(twinID, this.client.mnemonicOrSeed);
+      const headers = await createAuthHeader(twinID, this.client.mnemonicOrSeed, this.client.keypairType);
 
       const data = await this.client.patch<any>(`${this.accountUri}/${twinID}`, body, { headers });
       return data;

packages/registrar_client/src/modules/farms.ts

@@ -52,7 +52,7 @@ export class Farms {
     }
 
     const farm = { farm_name: farmName, dedicated, twin_id: twinID, stellar_address: stellarAddress };
-    const headers = await createAuthHeader(twinID, this.client.mnemonicOrSeed);
+    const headers = await createAuthHeader(twinID, this.client.mnemonicOrSeed, this.client.keypairType);
     try {
       const data = await this.client.post<FarmCreationResponse>(`${this.farmUri}/`, farm, { headers });
       return data;
@@ -94,7 +94,7 @@ export class Farms {
       throw new Error("Invalid stellar address");
     }
 
-    const headers = await createAuthHeader(twinID, this.client.mnemonicOrSeed);
+    const headers = await createAuthHeader(twinID, this.client.mnemonicOrSeed, this.client.keypairType);
     const farm : FarmUpdateRequest = { farm_name: name, stellar_address: stellarAddress };
     try {
       const data = await this.client.patch<any>(`${this.farmUri}/${farmID}`,farm , { headers });

packages/registrar_client/src/modules/nodes.ts

@@ -19,7 +19,7 @@ export class Nodes {
 
   async registerNode(node: NodeRegistrationRequest): Promise<NodeRegistrationResponse> {
     this._validateNodeData(node);
-    const headers = await createAuthHeader(node.twin_id, this.client.mnemonicOrSeed);
+    const headers = await createAuthHeader(node.twin_id, this.client.mnemonicOrSeed, this.client.keypairType);
     try {
       const data = await this.client.post<NodeRegistrationResponse>(`${this.nodeUri}/`, node, { headers });
       return data;
@@ -50,7 +50,7 @@ export class Nodes {
 
   async updateNode(nodeID: number, twinID: number, node: UpdateNodeRequest): Promise<any> {
     this._validateNodeData(node);
-    const headers = await createAuthHeader(twinID, this.client.mnemonicOrSeed);
+    const headers = await createAuthHeader(twinID, this.client.mnemonicOrSeed, this.client.keypairType);
     try {
       const data = await this.client.patch<Node>(`${this.nodeUri}/${nodeID}`, node, { headers });
       return data;
@@ -60,7 +60,7 @@ export class Nodes {
   }
 
   async reportNodeUptime(nodeID: number, twinID: number, uptime: UptimeReportRequest): Promise<any> {
-    const headers = await createAuthHeader(twinID, this.client.mnemonicOrSeed);
+    const headers = await createAuthHeader(twinID, this.client.mnemonicOrSeed, this.client.keypairType);
     try {
       const data = await this.client.post<any>(`${this.nodeUri}/${nodeID}/uptime`, uptime, { headers });
       return data;

packages/registrar_client/src/utils.ts

@@ -7,7 +7,7 @@ import { KeyringPair } from "@polkadot/keyring/types";
 import { validateMnemonic } from "bip39";
 import { cryptoWaitReady } from "@polkadot/util-crypto";
 
-const SUPPORTED_KEYPAIR_TYPES: KeypairType[] = ["sr25519", "ed25519"];
+export const SUPPORTED_KEYPAIR_TYPES: KeypairType[] = ["sr25519", "ed25519"];
 
 
 
@@ -18,7 +18,7 @@ function createSignatureForChallenge(challenge: string, keypair: KeyringPair): s
 
 export async function deriveKeyPair(
   mnemonicOrSeed: string,
-  keypairType: KeypairType = SUPPORTED_KEYPAIR_TYPES[0],
+  keypairType: KeypairType
 ): Promise<KeyringPair> {
   if (!SUPPORTED_KEYPAIR_TYPES.includes(keypairType)) {
     throw new Error(`Unsupported keypair type: ${keypairType}`);
@@ -35,17 +35,18 @@ export async function deriveKeyPair(
 
 export async function createSignatureWithPublicKey(
   mnemonicOrSeed: string,
+  keypairType: KeypairType ,
 ): Promise<{ signature: string; publicKey: string; timestamp: number }> {
-  const keypair = await deriveKeyPair(mnemonicOrSeed);
+  const keypair = await deriveKeyPair(mnemonicOrSeed, keypairType);
   const publicKey = base64.fromByteArray(keypair.publicKey);
   const timestamp = Math.floor(Date.now() / 1000);
   const challenge = `${timestamp}:${publicKey}`;
   const signature = createSignatureForChallenge(challenge, keypair);
   return { signature, publicKey, timestamp };
 }
 
-export async function createAuthHeader(twinID: number, mnemonicOrSeed: string): Promise<AxiosRequestConfig["headers"]> {
-  const keypair = await deriveKeyPair(mnemonicOrSeed);
+export async function createAuthHeader(twinID: number, mnemonicOrSeed: string, keypairType: KeypairType): Promise<AxiosRequestConfig["headers"]> {
+  const keypair = await deriveKeyPair(mnemonicOrSeed, keypairType);
   const timestamp = Math.floor(Date.now() / 1000);
   const challenge = `${timestamp}:${twinID}`;
   const signature = createSignatureForChallenge(challenge, keypair);