refactor(rpc): add stx_signTransaction, test schemas, closes leather-…

…io/issues#13

packages/rpc/package.json

@@ -21,7 +21,8 @@
     "zod": "3.23.8"
   },
   "devDependencies": {
-    "tsup": "8.1.0"
+    "tsup": "8.1.0",
+    "vitest": "2.0.5"
   },
   "files": [
     "dist"

packages/rpc/src/index.ts

@@ -6,33 +6,37 @@ import { DefineSendTransferMethod } from './methods/send-transfer';
 import { DefineSignMessageMethod } from './methods/sign-message';
 import { DefineSignPsbtMethod } from './methods/sign-psbt';
 import { DefineStxSignMessageMethod } from './methods/stx-sign-message';
-import { ExtractSuccessResponse } from './rpc';
+import { DefineStxSignTransactionMethod } from './methods/stx-sign-transaction';
+import { ExtractErrorResponse, ExtractSuccessResponse } from './rpc/schemas';
 
-export * from './rpc';
+export * from './rpc/schemas';
 export * from './methods/get-info';
 export * from './methods/sign-psbt';
 export * from './methods/get-addresses';
 export * from './methods/send-transfer';
+export * from './methods/sign-message';
+export * from './methods/stx-sign-message';
 
-export type MethodMap = DefineGetInfoMethod &
+export type LeatherRpcMethodMap = DefineGetInfoMethod &
   DefineGetAddressesMethod &
   DefineSignPsbtMethod &
   DefineSignMessageMethod &
   DefineSendTransferMethod &
-  DefineStxSignMessageMethod;
+  DefineStxSignMessageMethod &
+  DefineStxSignTransactionMethod;
 
-export type RpcRequests = ValueOf<MethodMap>['request'];
+export type RpcRequests = ValueOf<LeatherRpcMethodMap>['request'];
 
-export type RpcResponses = ValueOf<MethodMap>['response'];
+export type RpcResponses = ValueOf<LeatherRpcMethodMap>['response'];
 
-export type MethodNames = keyof MethodMap;
+export type MethodNames = keyof LeatherRpcMethodMap;
 
 export interface RequestFn {
   <T extends MethodNames>(
     arg: T,
     params?: object | string[]
     // `Promise` throws if unsucessful, so here we extract the successful response
-  ): Promise<ExtractSuccessResponse<MethodMap[T]['response']>>;
+  ): Promise<ExtractSuccessResponse<LeatherRpcMethodMap[T]['response']>>;
 }
 
 export interface ListenFn {
@@ -64,3 +68,19 @@ export interface LeatherProvider {
    */
   listen: ListenFn;
 }
+
+export function createRpcSuccessResponse<T extends MethodNames>(
+  _method: T,
+  response: Omit<ExtractSuccessResponse<LeatherRpcMethodMap[T]['response']>, 'jsonrpc'>
+) {
+  return { jsonrpc: '2.0', ...response } as ExtractSuccessResponse<
+    LeatherRpcMethodMap[T]['response']
+  >;
+}
+
+export function createRpcErrorResponse<T extends MethodNames>(
+  _method: T,
+  error: Omit<ExtractErrorResponse<LeatherRpcMethodMap[T]['response']>['error'], 'jsonrpc'>
+) {
+  return { jsonrpc: '2.0', error } as ExtractErrorResponse<LeatherRpcMethodMap[T]['response']>;
+}

packages/rpc/src/methods/get-addresses.ts

@@ -1,6 +1,6 @@
 import { AllowAdditionalProperties } from '@leather.io/models';
 
-import { DefineRpcMethod, RpcRequest, RpcResponse } from '../rpc';
+import { DefineRpcMethod, RpcRequest, RpcResponse } from '../rpc/schemas';
 
 export type PaymentTypes = 'p2pkh' | 'p2sh' | 'p2wpkh-p2sh' | 'p2wpkh' | 'p2tr';
 

packages/rpc/src/methods/get-info.ts

@@ -1,4 +1,4 @@
-import { DefineRpcMethod, RpcRequest, RpcResponse } from '../rpc';
+import { DefineRpcMethod, RpcRequest, RpcResponse } from '../rpc/schemas';
 
 interface GetInfoResponseBody {
   version: string;

packages/rpc/src/methods/send-transfer.ts

@@ -1,4 +1,4 @@
-import { DefineRpcMethod, RpcRequest, RpcResponse } from '../rpc';
+import { DefineRpcMethod, RpcRequest, RpcResponse } from '../rpc/schemas';
 
 export interface SendTransferRequestParams {
   account?: number;

packages/rpc/src/methods/sign-message.ts

@@ -1,6 +1,6 @@
 import { AllowAdditionalProperties } from '@leather.io/models';
 
-import { DefineRpcMethod, RpcRequest, RpcResponse } from '../rpc';
+import { DefineRpcMethod, RpcRequest, RpcResponse } from '../rpc/schemas';
 import { PaymentTypes } from './get-addresses';
 
 // Implements BIP-322

packages/rpc/src/methods/sign-psbt.ts

@@ -1,6 +1,6 @@
 import { DefaultNetworkConfigurations } from '@leather.io/models';
 
-import { DefineRpcMethod, RpcRequest, RpcResponse } from '../rpc';
+import { DefineRpcMethod, RpcRequest, RpcResponse } from '../rpc/schemas';
 
 /**
  * DEFAULT       -- all inputs, all outputs

packages/rpc/src/methods/stx-sign-message.ts

@@ -1,6 +1,8 @@
-import { DefineRpcMethod, RpcRequest, RpcResponse } from '../rpc';
+import { DefineRpcMethod, RpcRequest, RpcResponse } from '../rpc/schemas';
 
-export type StxSignMessageTypes = 'utf8' | 'structured';
+export const stxMessageSigningTypes = ['utf8', 'structured'] as const;
+
+export type StxSignMessageTypes = (typeof stxMessageSigningTypes)[number];
 
 export interface StxSignMessageRequestParamsBase {
   type: StxSignMessageTypes;

packages/rpc/src/methods/stx-sign-transaction.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+
+import { DefineRpcMethod, RpcRequest, RpcResponse } from '../rpc/schemas';
+
+export const stxSignTransactionMethodName = 'stx_signTransaction' as const;
+
+const stxSignTransactionRequestParamsSchema = z.object({
+  txHex: z.string(),
+  stxAddress: z.string().optional(),
+  attachment: z.string().optional(),
+});
+
+export type StxSignTransactionRequestParams = z.infer<typeof stxSignTransactionRequestParamsSchema>;
+
+const stxSignTransactionResponseSchema = z.object({ txHex: z.string() });
+
+export type StxSignTransactionResponseBody = z.infer<typeof stxSignTransactionResponseSchema>;
+
+export type StxSignTransactionRequest = RpcRequest<
+  typeof stxSignTransactionMethodName,
+  StxSignTransactionRequestParams
+>;
+
+export type StxSignTransactionResponse = RpcResponse<StxSignTransactionResponseBody>;
+
+export type DefineStxSignTransactionMethod = DefineRpcMethod<
+  StxSignTransactionRequest,
+  StxSignTransactionResponse
+>;

packages/rpc/src/rpc/schemas.spec.ts

@@ -0,0 +1,107 @@
+import { z } from 'zod';
+
+import {
+  createRpcErrorResponseSchema,
+  createRpcSuccessResponseSchema,
+  rpcBasePropsSchema,
+} from './schemas';
+
+const baseRequestData = { jsonrpc: '2.0', id: '1' };
+
+describe('RPC method schemas', () => {
+  test('the base RPC schema', () => {
+    expect(rpcBasePropsSchema.safeParse(baseRequestData).success).toEqual(true);
+  });
+
+  describe(createRpcSuccessResponseSchema.name, () => {
+    test('validates a successful response with basic result object', () => {
+      const schema = createRpcSuccessResponseSchema(z.object({ value: z.string() }));
+      const validResponse = { ...baseRequestData, result: { value: 'test' } };
+
+      expect(schema.safeParse(validResponse).success).toBe(true);
+    });
+
+    test('fails validation when missing required RPC base properties', () => {
+      const schema = createRpcSuccessResponseSchema(z.object({ value: z.string() }));
+      const invalidResponse = { result: { value: 'test' } };
+
+      expect(schema.safeParse(invalidResponse).success).toBe(false);
+    });
+
+    test('fails validation when result does not match schema', () => {
+      const schema = createRpcSuccessResponseSchema(z.object({ value: z.number() }));
+      const invalidResponse = { ...baseRequestData, result: { value: 'not a number' } };
+
+      expect(schema.safeParse(invalidResponse).success).toBe(false);
+    });
+  });
+
+  describe(createRpcErrorResponseSchema.name, () => {
+    const rpcErrorSchema = z.object({
+      code: z.number(),
+      message: z.string(),
+      data: z.object({}).optional(),
+    });
+
+    test('validates error response with basic error object', () => {
+      const schema = createRpcErrorResponseSchema(rpcErrorSchema);
+      const validResponse = {
+        ...baseRequestData,
+        error: {
+          code: -32600,
+          message: 'Invalid Request',
+        },
+      };
+
+      expect(schema.safeParse(validResponse).success).toBe(true);
+    });
+
+    test('validates error response with optional error data', () => {
+      const schema = createRpcErrorResponseSchema(rpcErrorSchema);
+      const validResponse = {
+        ...baseRequestData,
+        error: {
+          code: -32603,
+          message: 'Internal error',
+          data: { details: 'Database connection failed' },
+        },
+      };
+
+      expect(schema.safeParse(validResponse).success).toBe(true);
+    });
+
+    test('fails validation when missing required RPC properties', () => {
+      const schema = createRpcErrorResponseSchema(rpcErrorSchema);
+      const invalidResponse = {
+        error: {
+          code: -32600,
+          message: 'Invalid Request',
+        },
+      };
+      expect(schema.safeParse(invalidResponse).success).toBe(false);
+    });
+
+    test('fails validation with invalid error code', () => {
+      const schema = createRpcErrorResponseSchema(rpcErrorSchema);
+      const invalidResponse = {
+        ...baseRequestData,
+        error: {
+          code: 'not-a-number',
+          message: 'Invalid Request',
+        },
+      };
+
+      expect(schema.safeParse(invalidResponse).success).toBe(false);
+    });
+
+    test('fails validation when missing error message', () => {
+      const schema = createRpcErrorResponseSchema(rpcErrorSchema);
+      const invalidResponse = {
+        ...baseRequestData,
+        error: { code: -32600 },
+      };
+
+      expect(schema.safeParse(invalidResponse).success).toBe(false);
+    });
+  });
+});