feat(minajs): improve tx send and add value utils

Author: mrcnk

.github/workflows/ci.yml

@@ -12,4 +12,4 @@ jobs:
       - run: bun i --no-save
       - run: bun run build
       - run: bun run test
-      - run: bunx pkg-pr-new publish './packages/klesia-sdk' './packages/accounts' './packages/connect' './packages/providers' './packages/shared'
+      - run: bunx pkg-pr-new publish './packages/klesia-sdk' './packages/accounts' './packages/connect' './packages/providers' './packages/utils'

apps/klesia/package.json

@@ -21,7 +21,7 @@
 	"dependencies": {
 		"@hono/node-server": "^1.12.2",
 		"@hono/zod-openapi": "^0.16.0",
-		"@mina-js/shared": "workspace:*",
+		"@mina-js/utils": "workspace:*",
 		"@urql/core": "^5.0.6",
 		"bigint-quantile": "^0.0.2",
 		"dayjs": "^1.11.13",

apps/klesia/src/index.ts

@@ -1,7 +1,7 @@
 import "dotenv/config";
 import { getConnInfo } from "@hono/node-server/conninfo";
 import { OpenAPIHono, createRoute } from "@hono/zod-openapi";
-import { PublicKeySchema } from "@mina-js/shared";
+import { PublicKeySchema } from "@mina-js/utils";
 import { rateLimiter } from "hono-rate-limiter";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";

apps/klesia/src/methods/mina.ts

@@ -1,7 +1,11 @@
-import { SignedTransactionSchema } from "@mina-js/shared";
 import { gql } from "@urql/core";
 import { calculateQuantile } from "bigint-quantile";
 import { match } from "ts-pattern";
+import {
+	SendDelegationBodySchema,
+	SendTransactionBodySchema,
+	SendZkAppBodySchema,
+} from "../schema";
 import { getNodeClient } from "../utils/node";
 
 export const PRIORITY = {
@@ -91,8 +95,8 @@ const sendTransaction = async ({
 	const client = getNodeClient();
 	return match(type)
 		.with("payment", async () => {
-			const { signature, data: input } =
-				SignedTransactionSchema.parse(signedTransaction);
+			const { signature, input } =
+				SendTransactionBodySchema.parse(signedTransaction);
 			const { data } = await client.mutation(
 				gql`
           mutation {
@@ -108,8 +112,8 @@ const sendTransaction = async ({
 			return data.sendPayment.payment.hash;
 		})
 		.with("delegation", async () => {
-			const { signature, data: input } =
-				SignedTransactionSchema.parse(signedTransaction);
+			const { signature, input } =
+				SendDelegationBodySchema.parse(signedTransaction);
 			const { data } = await client.mutation(
 				gql`
           mutation {
@@ -125,6 +129,7 @@ const sendTransaction = async ({
 			return data.sendDelegation.delegation.hash;
 		})
 		.with("zkapp", async () => {
+			const { input } = SendZkAppBodySchema.parse(signedTransaction);
 			const { data } = await client.mutation(
 				gql`
           mutation {
@@ -135,7 +140,7 @@ const sendTransaction = async ({
             }
           }
         `,
-				{ input: signedTransaction },
+				{ input },
 			);
 			return data.sendZkapp.zkapp.hash;
 		})

apps/klesia/src/schema.ts

@@ -1,10 +1,40 @@
-import { PublicKeySchema } from "@mina-js/shared";
+import {
+	PublicKeySchema,
+	TransportableDelegationPayload,
+	TransportableTransactionPayload,
+} from "@mina-js/utils";
 import { z } from "zod";
+import { SendZkappInput } from "./zkapp";
 
 export const KlesiaNetwork = z.enum(["devnet", "mainnet", "zeko_devnet"]);
 export const PublicKeyParamsSchema = z.array(PublicKeySchema).length(1);
 export const EmptyParamsSchema = z.array(z.string()).length(0).optional();
-export const SendTransactionSchema = z.array(z.any(), z.string()).length(2);
+export const SignatureSchema = z.union([
+	z.object({
+		rawSignature: z.string(),
+	}),
+	z.object({ field: z.string(), scalar: z.string() }),
+]);
+export const SendTransactionBodySchema = z.object({
+	input: TransportableTransactionPayload,
+	signature: SignatureSchema,
+});
+export const SendDelegationBodySchema = z.object({
+	input: TransportableDelegationPayload,
+	signature: SignatureSchema,
+});
+export const SendZkAppBodySchema = z.object({
+	input: SendZkappInput,
+});
+export const SendableSchema = z.union([
+	SendTransactionBodySchema,
+	SendDelegationBodySchema,
+	SendZkAppBodySchema,
+]);
+export const SendTransactionSchema = z.tuple([
+	SendableSchema,
+	z.enum(["payment", "delegation", "zkapp"]),
+]);
 
 export const RpcMethod = z.enum([
 	"mina_getTransactionCount",

apps/klesia/src/zkapp.ts

@@ -0,0 +1,184 @@
+import { z } from "zod";
+
+// Helper schemas
+const PublicKey = z.string();
+const Signature = z.string();
+const Field = z.string();
+const TokenId = z.string();
+const UInt32 = z.number().int();
+const UInt64 = z.number().int();
+const BooleanSchema = z.boolean();
+const AuthRequired = z.enum([
+	"None",
+	"Proof",
+	"Signature",
+	"Either",
+	"Impossible",
+]);
+const Sign = z.enum(["Positive", "Negative"]);
+const Memo = z.string();
+const ZkappProof = z.string();
+
+// Complex nested schemas
+const VerificationKeyWithHashInput = z.object({
+	data: z.string(),
+	hash: Field,
+});
+
+const PermissionsInput = z.object({
+	editState: AuthRequired,
+	access: AuthRequired,
+	send: AuthRequired,
+	receive: AuthRequired,
+	setDelegate: AuthRequired,
+	setPermissions: AuthRequired,
+	setVerificationKey: z.object({
+		auth: AuthRequired,
+		txnVersion: UInt32,
+	}),
+	setZkappUri: AuthRequired,
+	editActionState: AuthRequired,
+	setTokenSymbol: AuthRequired,
+	incrementNonce: AuthRequired,
+	setVotingFor: AuthRequired,
+	setTiming: AuthRequired,
+});
+
+const TimingInput = z.object({
+	initialMinimumBalance: UInt64,
+	cliffTime: UInt32,
+	cliffAmount: UInt64,
+	vestingPeriod: UInt32,
+	vestingIncrement: UInt64,
+});
+
+const AccountUpdateModificationInput = z.object({
+	appState: z.array(Field).optional(),
+	delegate: PublicKey.optional(),
+	verificationKey: VerificationKeyWithHashInput.optional(),
+	permissions: PermissionsInput.optional(),
+	zkappUri: z.string().optional(),
+	tokenSymbol: z.string().optional(),
+	timing: TimingInput.optional(),
+	votingFor: Field.optional(),
+});
+
+const BalanceChangeInput = z.object({
+	magnitude: UInt64,
+	sgn: Sign,
+});
+
+const CurrencyAmountIntervalInput = z.object({
+	lower: UInt64,
+	upper: UInt64,
+});
+
+const LengthIntervalInput = z.object({
+	lower: UInt32,
+	upper: UInt32,
+});
+
+const GlobalSlotSinceGenesisIntervalInput = z.object({
+	lower: UInt32,
+	upper: UInt32,
+});
+
+const EpochLedgerPreconditionInput = z.object({
+	hash: Field.optional(),
+	totalCurrency: CurrencyAmountIntervalInput.optional(),
+});
+
+const EpochDataPreconditionInput = z.object({
+	ledger: EpochLedgerPreconditionInput,
+	seed: Field.optional(),
+	startCheckpoint: Field.optional(),
+	lockCheckpoint: Field.optional(),
+	epochLength: LengthIntervalInput.optional(),
+});
+
+const NetworkPreconditionInput = z.object({
+	snarkedLedgerHash: Field.optional(),
+	blockchainLength: LengthIntervalInput.optional(),
+	minWindowDensity: LengthIntervalInput.optional(),
+	totalCurrency: CurrencyAmountIntervalInput.optional(),
+	globalSlotSinceGenesis: GlobalSlotSinceGenesisIntervalInput.optional(),
+	stakingEpochData: EpochDataPreconditionInput,
+	nextEpochData: EpochDataPreconditionInput,
+});
+
+const AccountPreconditionInput = z.object({
+	balance: CurrencyAmountIntervalInput.optional(),
+	nonce: LengthIntervalInput.optional(),
+	receiptChainHash: Field.optional(),
+	delegate: PublicKey.optional(),
+	state: z.array(Field),
+	actionState: Field.optional(),
+	provedState: BooleanSchema.optional(),
+	isNew: BooleanSchema.optional(),
+});
+
+const PreconditionsInput = z.object({
+	network: NetworkPreconditionInput,
+	account: AccountPreconditionInput,
+	validWhile: GlobalSlotSinceGenesisIntervalInput.optional(),
+});
+
+const MayUseTokenInput = z.object({
+	parentsOwnToken: BooleanSchema,
+	inheritFromParent: BooleanSchema,
+});
+
+const AuthorizationKindStructuredInput = z.object({
+	isSigned: BooleanSchema,
+	isProved: BooleanSchema,
+	verificationKeyHash: Field,
+});
+
+const AccountUpdateBodyInput = z.object({
+	publicKey: PublicKey,
+	tokenId: TokenId,
+	update: AccountUpdateModificationInput,
+	balanceChange: BalanceChangeInput,
+	incrementNonce: BooleanSchema,
+	events: z.array(z.array(Field)),
+	actions: z.array(z.array(Field)),
+	callData: Field,
+	callDepth: z.number().int(),
+	preconditions: PreconditionsInput,
+	useFullCommitment: BooleanSchema,
+	implicitAccountCreationFee: BooleanSchema,
+	mayUseToken: MayUseTokenInput,
+	authorizationKind: AuthorizationKindStructuredInput,
+});
+
+const ControlInput = z.object({
+	proof: ZkappProof.optional(),
+	signature: Signature.optional(),
+});
+
+const ZkappAccountUpdateInput = z.object({
+	body: AccountUpdateBodyInput,
+	authorization: ControlInput,
+});
+
+const FeePayerBodyInput = z.object({
+	publicKey: PublicKey,
+	fee: UInt64,
+	validUntil: UInt32.optional(),
+	nonce: UInt32,
+});
+
+const ZkappFeePayerInput = z.object({
+	body: FeePayerBodyInput,
+	authorization: Signature,
+});
+
+const ZkappCommandInput = z.object({
+	feePayer: ZkappFeePayerInput,
+	accountUpdates: z.array(ZkappAccountUpdateInput),
+	memo: Memo,
+});
+
+export const SendZkappInput = z.object({
+	zkappCommand: ZkappCommandInput,
+});

apps/klesia/tsup.config.ts

@@ -1,5 +1,5 @@
 import { defineConfig } from "tsup";
-import sharedConfig from "../../packages/shared/tsup.config";
+import sharedConfig from "../../packages/utils/tsup.config";
 
 export default defineConfig({
 	...sharedConfig,

bun.lockb

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

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

@@ -1,5 +1,5 @@
 import { expect, it } from "bun:test";
-import { Test } from "@mina-js/shared";
+import { Test } from "@mina-js/utils";
 import { privateKeyToAccount } from "./private-key-to-account";
 
 it("matches default values", () => {