feat(klesia): add experimental mina_estimateFees

Author: mrcnk

apps/klesia/package.json

@@ -23,6 +23,7 @@
 		"@hono/zod-openapi": "^0.16.0",
 		"@mina-js/shared": "workspace:*",
 		"@urql/core": "^5.0.6",
+		"bigint-quantile": "^0.0.2",
 		"dayjs": "^1.11.13",
 		"dotenv": "^16.4.5",
 		"hono": "^4.5.10",

apps/klesia/src/index.spec.ts

@@ -55,4 +55,16 @@ describe("Mina Devnet RPC", () => {
 		expect(BigInt(result.nonce)).toBeGreaterThanOrEqual(0);
 		expect(BigInt(result.balance)).toBeGreaterThanOrEqual(0);
 	});
+
+	it("returns result for mina_estimateFee", async () => {
+		const response = await request({
+			json: {
+				method: "mina_estimateFees",
+			},
+		});
+		const { result } = (await response.json()) as {
+			result: { medium: string };
+		};
+		expect(result.medium.length).toBeGreaterThan(0);
+	});
 });

apps/klesia/src/index.ts

@@ -123,6 +123,10 @@ export const klesiaRpcRoute = api.openapi(rpcRoute, async ({ req, json }) => {
 			});
 			return json(buildResponse({ result }), 200);
 		})
+		.with({ method: RpcMethod.enum.mina_estimateFees }, async () => {
+			const result = await mina.estimateFees();
+			return json(buildResponse({ result }), 200);
+		})
 		.exhaustive();
 });
 

apps/klesia/src/methods/mina.spec.ts

@@ -28,3 +28,8 @@ it("should get account info", async () => {
 	expect(BigInt(result.nonce)).toBeGreaterThanOrEqual(0);
 	expect(BigInt(result.balance)).toBeGreaterThanOrEqual(0);
 });
+
+it("should estimate fee", async () => {
+	const result = await mina.estimateFees();
+	expect(result.medium.length).toBeGreaterThan(0);
+});

apps/klesia/src/methods/mina.ts

@@ -1,8 +1,15 @@
 import { SignedTransactionSchema } from "@mina-js/shared";
 import { gql } from "@urql/core";
+import { calculateQuantile } from "bigint-quantile";
 import { match } from "ts-pattern";
 import { getNodeClient } from "../utils/node";
 
+export const PRIORITY = {
+	low: 0.25,
+	medium: 0.5,
+	high: 0.75,
+} as Record<string, number>;
+
 const getTransactionCount = async ({ publicKey }: { publicKey: string }) => {
 	const client = getNodeClient();
 	try {
@@ -163,11 +170,43 @@ const getAccount = async ({ publicKey }: { publicKey: string }) => {
 	}
 };
 
+const estimateFees = async () => {
+	const client = getNodeClient();
+	try {
+		const { data } = await client.query(
+			gql`
+        query {
+          snarkPool {
+            fee
+          }
+        }
+      `,
+			{},
+		);
+		const fees = data.snarkPool
+			.map((entry: { fee: string }) => entry.fee)
+			.filter((entry: string) => entry !== "0")
+			.map((entry: string) => BigInt(entry));
+		return {
+			low: String(calculateQuantile(fees, PRIORITY.low)),
+			medium: String(calculateQuantile(fees, PRIORITY.medium)),
+			high: String(calculateQuantile(fees, PRIORITY.high)),
+		};
+	} catch {
+		return {
+			low: "10000000",
+			medium: "100000000",
+			high: "200000000",
+		};
+	}
+};
+
 export const mina = {
 	getTransactionCount,
 	getBalance,
 	blockHash,
 	chainId,
 	sendTransaction,
 	getAccount,
+	estimateFees,
 };

apps/klesia/src/schema.ts

@@ -13,6 +13,7 @@ export const RpcMethod = z.enum([
 	"mina_chainId",
 	"mina_sendTransaction",
 	"mina_getAccount",
+	"mina_estimateFees",
 ]);
 export type RpcMethodType = z.infer<typeof RpcMethod>;
 
@@ -41,6 +42,10 @@ export const RpcMethodSchema = z.discriminatedUnion("method", [
 		method: z.literal(RpcMethod.enum.mina_getAccount),
 		params: PublicKeyParamsSchema,
 	}),
+	z.object({
+		method: z.literal(RpcMethod.enum.mina_estimateFees),
+		params: EmptyParamsSchema,
+	}),
 ]);
 
 export const JsonRpcResponse = z.object({
@@ -87,6 +92,14 @@ export const RpcResponseSchema = z.union([
 				balance: z.string(),
 			}),
 		}),
+		JsonRpcResponse.extend({
+			method: z.literal(RpcMethod.enum.mina_estimateFees),
+			result: z.object({
+				low: z.string(),
+				medium: z.string(),
+				high: z.string(),
+			}),
+		}),
 	]),
 	ErrorSchema,
 ]);

bun.lockb

@@ -9,3 +9,5 @@ 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";
+
+export * from "./types";

packages/accounts/src/index.ts

@@ -2,14 +2,26 @@
 
 exports[`matches snapshot of local source 1`] = `
 {
+  "createNullifier": [Function: AsyncFunction],
   "getAccounts": [Function: AsyncFunction],
   "getBalance": [Function: AsyncFunction],
+  "getChainId": [Function: AsyncFunction],
+  "getTransactionCount": [Function: AsyncFunction],
+  "signFields": [Function: AsyncFunction],
+  "signMessage": [Function: AsyncFunction],
+  "signTransaction": [Function: AsyncFunction],
 }
 `;
 
 exports[`matches snapshot of json-rpc source 1`] = `
 {
+  "createNullifier": [Function: AsyncFunction],
   "getAccounts": [Function: AsyncFunction],
   "getBalance": [Function: AsyncFunction],
+  "getChainId": [Function: AsyncFunction],
+  "getTransactionCount": [Function: AsyncFunction],
+  "signFields": [Function: AsyncFunction],
+  "signMessage": [Function: AsyncFunction],
+  "signTransaction": [Function: AsyncFunction],
 }
 `;

packages/connect/src/__snapshots__/client.spec.ts.snap

@@ -32,11 +32,47 @@ describe("json-rpc source", () => {
 		expect(accounts[0]).toEqual(PUBLIC_KEY);
 	});
 
-	// it('returns balance', async () => {
-	//   const account = toAccount(PUBLIC_KEY)
-	//   const client = createWalletClient({ account, network: 'devnet', providerSource: 'klesia' })
-	//   const balance = await client.getBalance()
-	//   console.log(balance)
-	//   expect(balance).toBeGreaterThanOrEqual(0)
-	// })
+	it("returns balance", async () => {
+		const account = toAccount(PUBLIC_KEY);
+		const client = createWalletClient({
+			account,
+			network: "devnet",
+			providerSource: "klesia",
+		});
+		const balance = await client.getBalance();
+		expect(balance).toBeGreaterThanOrEqual(0);
+	});
+
+	it("returns transaction count", async () => {
+		const account = toAccount(PUBLIC_KEY);
+		const client = createWalletClient({
+			account,
+			network: "devnet",
+			providerSource: "klesia",
+		});
+		const transactionCount = await client.getTransactionCount();
+		expect(transactionCount).toBeGreaterThanOrEqual(0);
+	});
+
+	it("returns chain id", async () => {
+		const account = toAccount(PUBLIC_KEY);
+		const client = createWalletClient({
+			account,
+			network: "devnet",
+			providerSource: "klesia",
+		});
+		const chainId = await client.getChainId();
+		expect(chainId.length).toBeGreaterThan(0);
+	});
+});
+
+describe("local source", () => {
+	it("signs a message", async () => {
+		const account = privateKeyToAccount({
+			privateKey: Test.accounts[0].privateKey,
+		});
+		const client = createWalletClient({ account, network: "devnet" });
+		const signature = await client.signMessage({ message: "hello" });
+		expect(signature.data).toEqual("hello");
+	});
 });