Development support mnemonics in registrar client

packages/registrar_client/README.md

@@ -35,24 +35,37 @@ 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 Base64-encoded, 64-byte raw Ed25519 private key (nacl format).
+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.
 
-To generate a 64-byte ed25519 private key, you can use tweetnacl library to generate key:
+The supported keypair types are:
+
+- `ed25519`
+- `sr25519` (default)
+
+Here's how to initialize the client:
 
 ```typescript
-import nacl from "tweetnacl";
-import base64 from "base64-js";
+const client = new RegistrarClient({
+  baseUrl: "https://registrar.dev4.grid.tf/v1",
+  mnemonicOrSeed: "your_mnemonic_or_seed",
+  keypairType: "sr25519", // Optional, defaults to "sr25519"
+});
+```
 
-const keyPair = nacl.sign.keyPair();
-const privateKey = base64.fromByteArray(keyPair.secretKey);
+To generate 64 character hex seed:
 
-console.log("Your 64-byte ed25519 private key:", privateKey);
+```bash
+openssl rand -hex 32
 ```
 
 Here is an example:
 
 ```typescript
-const client = new RegistrarClient({ baseURl: "https://registrar.dev4.grid.tf/v1", privateKey: your_private_key });
+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/).
@@ -62,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, privateKey: your_private_key });
+const client = new RegistrarClient({ baseUrl: URl, mnemonicOrSeed: your_mnemonic_or_seed, keypairType: "ed21559" });
 
 // Example: Create an account
 const accountRequest: CreateAccountRequest = {

packages/registrar_client/package.json

@@ -54,8 +54,10 @@
     "typescript": "^5.7.3"
   },
   "dependencies": {
+    "@polkadot/keyring": "^13.4.4",
     "@stellar/stellar-base": "^12.1.1",
     "@types/jest": "^29.5.14",
+    "bip39": "^3.1.0",
     "dotenv": "^16.4.7",
     "jest": "^29.7.0",
     "ts-jest": "^29.2.5",

packages/registrar_client/scripts/README.md

@@ -16,12 +16,12 @@ yarn install
 
 ## Getting Started
 
-- Set base URL, your private key, 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": "http://localhost:8080/v1", "privateKey": "", "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, privateKey: config.privateKey });
+  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

@@ -1,12 +1,13 @@
 import { log } from "console";
 import { Account, RegistrarClient } from "../src/";
 import config from "./config.json";
-import * as tweetnacl from "tweetnacl";
 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 publicKey = tweetnacl.sign.keyPair.fromSecretKey(base64.toByteArray(config.privateKey)).publicKey;
-  const account = await client.accounts.getAccountByPublicKey(base64.fromByteArray(publicKey));
+  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);
   log("================= Getting Account =================");
@@ -29,7 +30,7 @@ async function getFarm(client: RegistrarClient, farmID: number) {
 }
 
 async function main() {
-  const client = new RegistrarClient({ baseURL: config.baseUrl, privateKey: config.privateKey });
+  const client = new RegistrarClient({ baseURL: config.baseUrl, mnemonicOrSeed: config.mnemonicOrSeed });
   const account = await getAccount(client);
   const twinID = account.twin_id;
   const farmID = await createFarm(client, twinID, config.stellarAddress);

packages/registrar_client/scripts/create_node.ts

@@ -1,12 +1,13 @@
 import { log } from "console";
 import { Account, RegistrarClient, NodeRegistrationRequest } from "../src/";
 import config from "./config.json";
-import * as tweetnacl from "tweetnacl";
 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 publicKey = tweetnacl.sign.keyPair.fromSecretKey(base64.toByteArray(config.privateKey)).publicKey;
-  const account = await client.accounts.getAccountByPublicKey(base64.fromByteArray(publicKey));
+  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);
   log("================= Getting Account =================");
@@ -29,7 +30,7 @@ async function getNode(client: RegistrarClient, nodeID: number) {
 }
 
 async function main() {
-  const client = new RegistrarClient({ baseURL: config.baseUrl, privateKey: config.privateKey });
+  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/list_farms.ts

@@ -9,7 +9,7 @@ async function listFarms(client: RegistrarClient, filter: NodesFilter) {
 }
 
 async function main() {
-  const client = new RegistrarClient({ baseURL: config.baseUrl, privateKey: config.privateKey });
+  const client = new RegistrarClient({ baseURL: config.baseUrl, mnemonicOrSeed: config.mnemonicOrSeed });
   await listFarms(client, {});
 }
 

packages/registrar_client/scripts/list_nodes.ts

@@ -9,7 +9,7 @@ async function listNodes(client: RegistrarClient, filter: NodesFilter) {
 }
 
 async function main() {
-  const client = new RegistrarClient({ baseURL: config.baseUrl, privateKey: config.privateKey });
+  const client = new RegistrarClient({ baseURL: config.baseUrl, mnemonicOrSeed: config.mnemonicOrSeed });
   const filter: NodesFilter = {
     farm_id: 70,
   };

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, privateKey: config.privateKey });
+  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, privateKey: config.privateKey });
+  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, privateKey: config.privateKey });
+  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 { KeypairType } from "@polkadot/util-crypto/types";
+import { SUPPORTED_KEYPAIR_TYPES } from "../utils";
 export abstract class BaseClient {
   private client: AxiosInstance;
 
@@ -35,25 +37,46 @@ export abstract class BaseClient {
 }
 interface Config {
   baseURL: string;
-  privateKey: string;
+  mnemonicOrSeed: string;
+  keypairType?: KeypairType;
 }
 
 export class RegistrarClient extends BaseClient {
-  public readonly privateKey: string;
+  public readonly mnemonicOrSeed: string;
+  public readonly keypairType: KeypairType;
   accounts: Accounts;
   farms: Farms;
   nodes: Nodes;
   zos: Zos;
 
-  constructor({ baseURL, privateKey }: Config) {
+  _validateSeed(seed: string): string {
+    if (!seed.startsWith("0x")) {
+      seed = `0x${seed}`;
+    }
+    if (!seed.match(/^0x[a-fA-F0-9]{64}$/)) {
+      return "";
+    }
+    return seed;
+  }
+
+  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");
     }
-    if (!privateKey) {
-      throw new Error("Private key is required");
-    }
     super(baseURL);
-    this.privateKey = privateKey;
+
+    if (!validateMnemonic(mnemonicOrSeed)) {
+      mnemonicOrSeed = this._validateSeed(mnemonicOrSeed);
+    }
+    if (!mnemonicOrSeed) {
+      throw new Error("Invalid mnemonic or seed");
+    }
+
+    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

@@ -1,7 +1,5 @@
 import { RegistrarClient } from "../client/client";
 import { Account, CreateAccountRequest, UpdateAccountRequest } from "../types/account";
-import * as tweetnacl from "tweetnacl";
-import * as base64 from "base64-js";
 import { createSignatureWithPublicKey, createAuthHeader } from "../utils";
 
 export class Accounts {
@@ -14,11 +12,7 @@ export class Accounts {
   }
 
   async createAccount(request: Partial<CreateAccountRequest>): Promise<Account | null> {
-    const privateKey = this.client.privateKey;
-    const keyPair = tweetnacl.sign.keyPair.fromSecretKey(base64.toByteArray(privateKey));
-
-    const publicKey = base64.fromByteArray(keyPair.publicKey);
-    const { signature, timestamp } = createSignatureWithPublicKey(publicKey, privateKey);
+    const { signature, publicKey, timestamp } = await createSignatureWithPublicKey(this.client.mnemonicOrSeed, this.client.keypairType);
 
     request.public_key = publicKey;
     request.signature = signature;
@@ -59,7 +53,7 @@ export class Accounts {
 
   async updateAccount(twinID: number, body: UpdateAccountRequest): Promise<any> {
     try {
-      const headers = createAuthHeader(twinID, this.client.privateKey);
+      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 = createAuthHeader(twinID, this.client.privateKey);
+    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 = createAuthHeader(twinID, this.client.privateKey);
+    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 = createAuthHeader(node.twin_id, this.client.privateKey);
+    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 = createAuthHeader(twinID, this.client.privateKey);
+    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 = createAuthHeader(twinID, this.client.privateKey);
+    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;