fix(klesia): handle unfunded accounts

Author: mrcnk

apps/docs/src/pages/about.mdx

@@ -23,20 +23,9 @@ MinaJS provides a set of services to interact with Mina Protocol. The services a
 graph TD
   classDef MinaJS fill:#C4A7E7,color:#000000
 
-  subgraph Klesia
-  G[Klesia RPC]:::MinaJS --> H[Mina Node]
-  H[Mina Node] --> G[Klesia RPC]
-  G[Klesia RPC]:::MinaJS --> J[Fallback Mina Node]
-  J[Fallback Mina Node] --> G[Klesia RPC]
-  end
-
   subgraph zkApp
   B[zkApp UI] --> C[MinaJS Connect]
   C[MinaJS Connect]:::MinaJS --> B[zkApp UI]
-  B[zkApp UI] --> I1[Klesia SDK - zkApp]
-  I1[Klesia SDK - zkApp]:::MinaJS --> G[Klesia RPC]
-  I1[Klesia SDK - zkApp]:::MinaJS --> B[zkApp UI]
-  G[Klesia RPC]:::MinaJS --> I1[Klesia SDK - zkApp]
   end
 
   subgraph Mina Wallet
@@ -46,11 +35,20 @@ graph TD
   E[Wallet UI & Connector] --> D[MinaJS Provider]
   E[Wallet UI & Connector] --> F[MinaJS Account]
   F[MinaJS Account]:::MinaJS --> E[Wallet UI & Connector]
-  I2[Klesia SDK - Wallet]:::MinaJS --> G[Klesia RPC]
-  G[Klesia RPC]:::MinaJS --> I2[Klesia SDK - Wallet]
   E[Wallet UI & Connector] --> I2[Klesia SDK - Wallet]
   I2[Klesia SDK - Wallet]:::MinaJS --> E[Wallet UI & Connector]
   end
+
+  subgraph Klesia
+  I2[Klesia SDK - Wallet]:::MinaJS --> G[Klesia RPC]
+  G[Klesia RPC]:::MinaJS --> H[Mina Node]
+  H[Mina Node] --> G[Klesia RPC]
+  G[Klesia RPC]:::MinaJS --> J[Fallback Mina Node]
+  J[Fallback Mina Node] --> G[Klesia RPC]
+  G[Klesia RPC]:::MinaJS --> I2[Klesia SDK - Wallet]
+  C[MinaJS Connect]:::MinaJS --> G[Klesia RPC]
+  G[Klesia RPC] --> C[MinaJS Connect]
+  end
 ```
 
 ## Supported Chains

apps/klesia/src/index.ts

@@ -71,7 +71,6 @@ export const klesiaRpcRoute = api.openapi(rpcRoute, async ({ req, json }) => {
 				});
 				return json(
 					buildResponse({
-						method: RpcMethod.enum.mina_getTransactionCount,
 						result,
 					}),
 					200,
@@ -83,16 +82,12 @@ export const klesiaRpcRoute = api.openapi(rpcRoute, async ({ req, json }) => {
 			const result = await mina.getBalance({
 				publicKey: PublicKeySchema.parse(publicKey),
 			});
-			return json(
-				buildResponse({ method: RpcMethod.enum.mina_getBalance, result }),
-				200,
-			);
+			return json(buildResponse({ result }), 200);
 		})
 		.with({ method: RpcMethod.enum.mina_blockHash }, async () => {
 			if (process.env.MINA_NETWORK === "zeko_devnet") {
 				return json(
 					buildResponse({
-						method: RpcMethod.enum.mina_blockHash,
 						error: {
 							code: -32600,
 							message: "Network not supported.",
@@ -102,17 +97,11 @@ export const klesiaRpcRoute = api.openapi(rpcRoute, async ({ req, json }) => {
 				);
 			}
 			const result = await mina.blockHash();
-			return json(
-				buildResponse({ method: RpcMethod.enum.mina_blockHash, result }),
-				200,
-			);
+			return json(buildResponse({ result }), 200);
 		})
 		.with({ method: RpcMethod.enum.mina_chainId }, async () => {
 			const result = await mina.chainId();
-			return json(
-				buildResponse({ method: RpcMethod.enum.mina_chainId, result }),
-				200,
-			);
+			return json(buildResponse({ result }), 200);
 		})
 		.with(
 			{ method: RpcMethod.enum.mina_sendTransaction },
@@ -121,7 +110,6 @@ export const klesiaRpcRoute = api.openapi(rpcRoute, async ({ req, json }) => {
 				const result = await mina.sendTransaction({ signedTransaction, type });
 				return json(
 					buildResponse({
-						method: RpcMethod.enum.mina_sendTransaction,
 						result,
 					}),
 					200,
@@ -133,10 +121,7 @@ export const klesiaRpcRoute = api.openapi(rpcRoute, async ({ req, json }) => {
 			const result = await mina.getAccount({
 				publicKey: PublicKeySchema.parse(publicKey),
 			});
-			return json(
-				buildResponse({ method: RpcMethod.enum.mina_getAccount, result }),
-				200,
-			);
+			return json(buildResponse({ result }), 200);
 		})
 		.exhaustive();
 });

apps/klesia/src/methods/mina.ts

@@ -5,34 +5,42 @@ import { getNodeClient } from "../utils/node";
 
 const getTransactionCount = async ({ publicKey }: { publicKey: string }) => {
 	const client = getNodeClient();
-	const { data } = await client.query(
-		gql`
-      query {
-        account(publicKey: $publicKey) {
-          nonce
+	try {
+		const { data } = await client.query(
+			gql`
+        query {
+          account(publicKey: $publicKey) {
+            nonce
+          }
         }
-      }
-    `,
-		{ publicKey },
-	);
-	return data.account.nonce;
+      `,
+			{ publicKey },
+		);
+		return data.account.nonce;
+	} catch {
+		return "0";
+	}
 };
 
 const getBalance = async ({ publicKey }: { publicKey: string }) => {
 	const client = getNodeClient();
-	const { data } = await client.query(
-		gql`
-      query {
-        account(publicKey: $publicKey) {
-          balance {
-            total
+	try {
+		const { data } = await client.query(
+			gql`
+        query {
+          account(publicKey: $publicKey) {
+            balance {
+              total
+            }
           }
         }
-      }
-    `,
-		{ publicKey },
-	);
-	return data.account.balance.total;
+      `,
+			{ publicKey },
+		);
+		return data.account.balance.total;
+	} catch {
+		return "0";
+	}
 };
 
 const blockHash = async () => {
@@ -129,8 +137,9 @@ const sendTransaction = async ({
 
 const getAccount = async ({ publicKey }: { publicKey: string }) => {
 	const client = getNodeClient();
-	const { data } = await client.query(
-		gql`
+	try {
+		const { data } = await client.query(
+			gql`
       query {
         account(publicKey: $publicKey) {
           nonce
@@ -140,12 +149,18 @@ const getAccount = async ({ publicKey }: { publicKey: string }) => {
         }
       }
     `,
-		{ publicKey },
-	);
-	return {
-		nonce: data.account.nonce,
-		balance: data.account.balance.total,
-	};
+			{ publicKey },
+		);
+		return {
+			nonce: data.account.nonce,
+			balance: data.account.balance.total,
+		};
+	} catch {
+		return {
+			nonce: "0",
+			balance: "0",
+		};
+	}
 };
 
 export const mina = {

apps/klesia/src/utils/build-response.ts

@@ -1,16 +1,14 @@
-import type { RpcErrorType, RpcMethodType } from "../schema";
+import type { RpcErrorType } from "../schema";
 
 export const buildResponse = ({
 	result,
 	error,
-	method,
-}: { result?: unknown; error?: RpcErrorType; method: RpcMethodType }) => {
+}: { result?: unknown; error?: RpcErrorType }) => {
 	if (error) {
 		return {
 			jsonrpc: "2.0",
 			error,
-			method,
 		};
 	}
-	return { jsonrpc: "2.0", result, method };
+	return { jsonrpc: "2.0", result };
 };

bun.lockb

@@ -3,14 +3,14 @@
 	"private": true,
 	"scripts": {
 		"build": "turbo build",
+		"build:packages": "turbo build --filter=\"./packages/*\"",
 		"test": "turbo test",
 		"cleanup": "bun run --filter '*' cleanup && rimraf node_modules .turbo",
 		"lint": "bunx biome check .",
 		"format": "bunx biome check . --write --unsafe"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "1.8.3",
-		"@happy-dom/global-registrator": "^14.12.3",
 		"@tsconfig/bun": "1.0.7",
 		"@types/bun": "1.1.6",
 		"rimraf": "^6.0.1",

package.json

@@ -1,8 +1,8 @@
 import { expect, it } from "bun:test";
-import { mnemonic } from "../test/constants";
+import { Test } from "@mina-js/shared";
 import { mnemonicToAccount } from "./mnemonic-to-account";
 
 it("matches the snapshot", () => {
-	const mnemonicAccount = mnemonicToAccount({ mnemonic });
+	const mnemonicAccount = mnemonicToAccount({ mnemonic: Test.mnemonic });
 	expect(mnemonicAccount).toMatchSnapshot();
 });

packages/accounts/src/accounts/mnemonic-to-account.spec.ts

@@ -1,21 +1,27 @@
 import { expect, it } from "bun:test";
-import { accounts } from "../test/constants";
+import { Test } from "@mina-js/shared";
 import { privateKeyToAccount } from "./private-key-to-account";
 
 it("matches default values", () => {
-	const account = privateKeyToAccount({ privateKey: accounts[0].privateKey });
+	const account = privateKeyToAccount({
+		privateKey: Test.accounts[0].privateKey,
+	});
 	expect(account).toMatchSnapshot();
 });
 
 it("signs a message", async () => {
-	const account = privateKeyToAccount({ privateKey: accounts[0].privateKey });
+	const account = privateKeyToAccount({
+		privateKey: Test.accounts[0].privateKey,
+	});
 	const message = "hello world";
 	const signedMessage = await account.signMessage({ message });
 	expect(signedMessage).toMatchSnapshot();
 });
 
 it("signs a transaction", async () => {
-	const account = privateKeyToAccount({ privateKey: accounts[0].privateKey });
+	const account = privateKeyToAccount({
+		privateKey: Test.accounts[0].privateKey,
+	});
 	const transaction = {
 		nonce: 1n,
 		from: "B62qmWKtvNQTtUqo1LxfEEDLyWMg59cp6U7c4uDC7aqgaCEijSc3Hx5",
@@ -28,14 +34,18 @@ it("signs a transaction", async () => {
 });
 
 it("creates a nullifier", async () => {
-	const account = privateKeyToAccount({ privateKey: accounts[0].privateKey });
+	const account = privateKeyToAccount({
+		privateKey: Test.accounts[0].privateKey,
+	});
 	const message = [1n, 2n, 3n];
 	const nullifier = await account.createNullifier({ message });
 	expect(typeof nullifier.private.c).toBe("bigint");
 });
 
 it("signs fields", async () => {
-	const account = privateKeyToAccount({ privateKey: accounts[0].privateKey });
+	const account = privateKeyToAccount({
+		privateKey: Test.accounts[0].privateKey,
+	});
 	const fields = [1n, 2n, 3n];
 	const signedFields = await account.signFields({ fields });
 	expect(signedFields).toMatchSnapshot();

packages/accounts/src/accounts/private-key-to-account.spec.ts

@@ -2,8 +2,10 @@ export { HDKey } from "@scure/bip32";
 export { hex } from "@scure/base";
 export { wordlist as english } from "@scure/bip39/wordlists/english";
 
+export type { Account } from "./types";
 export { generateMnemonic } from "./accounts/generate-mnemonic";
 export { generatePrivateKey } from "./accounts/generate-private-key";
 export { hdKeyToAccount } from "./accounts/hd-key-to-account";
 export { mnemonicToAccount } from "./accounts/mnemonic-to-account";
 export { privateKeyToAccount } from "./accounts/private-key-to-account";
+export { toAccount } from "./accounts/to-account";

packages/accounts/src/index.ts

@@ -67,6 +67,10 @@ export type HDAccount = Simplify<
 	}
 >;
 
+export type Account<publicKey extends PublicKey = PublicKey> =
+	| JsonRpcAccount<publicKey>
+	| LocalAccount<publicKey>;
+
 export type PrivateKeyAccount = Simplify<LocalAccount<"privateKey">>;
 
 export type { HDKey };