@walletmesh/aztec-rpc-wallet 0.3.0 → 0.4.0

package/src/serializers/transaction.ts

@@ -1,409 +0,0 @@
-import type { AztecWalletMethodMap } from '../types.js';
-import type { JSONRPCSerializedData, JSONRPCSerializer } from '@walletmesh/jsonrpc';
-import {
-  FunctionCall,
-  PrivateExecutionResult,
-  TxEffect,
-  TxSimulationResult,
-  inBlockSchemaFor,
-  TxHash,
-  TxProvingResult,
-} from '@aztec/circuit-types';
-import { GasSettings } from '@aztec/circuits.js';
-import {
-  AuthWitness,
-  AztecAddress,
-  Fr,
-  FunctionSelector,
-  HashedValues,
-  NoFeePaymentMethod,
-  TxExecutionRequest,
-  TxReceipt,
-  Tx,
-} from '@aztec/aztec.js';
-import { AbiTypeSchema, type FunctionType } from '@aztec/foundation/abi';
-
-import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
-import type { ExecutionRequestInit, FeeOptions } from '@aztec/aztec.js/entrypoint';
-
-interface SerializedFunctionCall {
-  name: string;
-  to: string;
-  selector: string;
-  type: string;
-  isStatic: boolean;
-  args: string[];
-  returnTypes: string[];
-}
-
-/**
- * Serializer for the aztec_createTxExecutionRequest RPC method.
- * Handles serialization of transaction execution requests between JSON-RPC format and native Aztec types.
- */
-export class AztecCreateTxExecutionRequestSerializer
-  implements
-    JSONRPCSerializer<
-      AztecWalletMethodMap['aztec_createTxExecutionRequest']['params'],
-      AztecWalletMethodMap['aztec_createTxExecutionRequest']['result']
-    >
-{
-  params = {
-    serialize: async (
-      method: string,
-      value: AztecWalletMethodMap['aztec_createTxExecutionRequest']['params'],
-    ): Promise<JSONRPCSerializedData> => {
-      const { exec } = value;
-
-      const calls = exec.calls.map((call: FunctionCall) => {
-        return {
-          name: call.name,
-          to: jsonStringify(call.to),
-          selector: jsonStringify(call.selector),
-          type: call.type,
-          isStatic: call.isStatic,
-          args: call.args.map((arg) => jsonStringify(arg)),
-          returnTypes: call.returnTypes.map((r) => jsonStringify(r)),
-        };
-      });
-      const authWitnesses = exec.authWitnesses ? exec.authWitnesses.map((w) => jsonStringify(w)) : undefined;
-      const hashedArguments = exec.hashedArguments
-        ? exec.hashedArguments.map((h) => jsonStringify(h))
-        : undefined;
-      const fee = { gasSettings: jsonStringify(exec.fee.gasSettings) };
-      const nonce = exec.nonce ? jsonStringify(exec.nonce) : undefined;
-
-      return {
-        method,
-        serialized: JSON.stringify({
-          calls,
-          fee,
-          authWitnesses,
-          hashedArguments,
-          nonce,
-          cancellable: exec.cancellable,
-        }),
-      };
-    },
-    deserialize: async (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): Promise<AztecWalletMethodMap['aztec_createTxExecutionRequest']['params']> => {
-      const parsed = JSON.parse(data.serialized);
-
-      const calls: FunctionCall[] = await Promise.all(
-        parsed.calls.map(async (call: SerializedFunctionCall) => {
-          return new FunctionCall(
-            call.name,
-            await jsonParseWithSchema(call.to, AztecAddress.schema),
-            await jsonParseWithSchema(call.selector, FunctionSelector.schema),
-            call.type as FunctionType,
-            call.isStatic,
-            await Promise.all(call.args.map(async (arg: string) => jsonParseWithSchema(arg, Fr.schema))),
-            await Promise.all(
-              call.returnTypes.map(async (t: string) => jsonParseWithSchema(t, AbiTypeSchema)),
-            ),
-          );
-        }),
-      );
-      const authWitnesses = parsed.authWitnesses
-        ? parsed.authWitnesses.map(async (w: string) => await jsonParseWithSchema(w, AuthWitness.schema))
-        : undefined;
-      const hashedArguments = parsed.hashedArguments
-        ? parsed.hashedArguments.map(async (h: string) => await jsonParseWithSchema(h, HashedValues.schema))
-        : undefined;
-      const cancellable = parsed.cancellable;
-      const nonce = parsed.nonce ? await jsonParseWithSchema(parsed.nonce, Fr.schema) : undefined;
-
-      const fee: FeeOptions = {
-        paymentMethod: new NoFeePaymentMethod(), // Default, caller should override
-        gasSettings: await jsonParseWithSchema(parsed.fee.gasSettings, GasSettings.schema),
-      };
-
-      const exec: ExecutionRequestInit = { calls, fee };
-      if (authWitnesses) exec.authWitnesses = authWitnesses;
-      if (hashedArguments) exec.hashedArguments = hashedArguments;
-      if (nonce) exec.nonce = nonce;
-      if (cancellable) exec.cancellable = cancellable;
-
-      return { exec };
-    },
-  };
-
-  result = {
-    serialize: async (method: string, value: TxExecutionRequest): Promise<JSONRPCSerializedData> => {
-      return {
-        method,
-        serialized: jsonStringify(value),
-      };
-    },
-    deserialize: async (_method: string, data: JSONRPCSerializedData): Promise<TxExecutionRequest> => {
-      return await jsonParseWithSchema(data.serialized, TxExecutionRequest.schema);
-    },
-  };
-}
-
-/**
- * Serializer for the aztec_proveTx RPC method.
- * Handles serialization of transaction proving requests and results between JSON-RPC format and native Aztec types.
- */
-export class AztecProveTxSerializer
-  implements
-    JSONRPCSerializer<
-      AztecWalletMethodMap['aztec_proveTx']['params'],
-      AztecWalletMethodMap['aztec_proveTx']['result']
-    >
-{
-  params = {
-    serialize: async (
-      method: string,
-      value: AztecWalletMethodMap['aztec_proveTx']['params'],
-    ): Promise<JSONRPCSerializedData> => {
-      const { txRequest, privateExecutionResult } = value;
-      return {
-        method,
-        serialized: JSON.stringify({
-          txRequest: jsonStringify(txRequest),
-          privateExecutionResult: jsonStringify(privateExecutionResult),
-        }),
-      };
-    },
-    deserialize: async (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): Promise<AztecWalletMethodMap['aztec_proveTx']['params']> => {
-      const { txRequest, privateExecutionResult } = JSON.parse(data.serialized);
-      return {
-        txRequest: await jsonParseWithSchema(txRequest, TxExecutionRequest.schema),
-        privateExecutionResult: await jsonParseWithSchema(
-          privateExecutionResult,
-          PrivateExecutionResult.schema,
-        ),
-      };
-    },
-  };
-
-  result = {
-    serialize: async (method: string, value: TxProvingResult): Promise<JSONRPCSerializedData> => {
-      return {
-        method,
-        serialized: jsonStringify(value),
-      };
-    },
-    deserialize: async (_method: string, data: JSONRPCSerializedData): Promise<TxProvingResult> => {
-      return await jsonParseWithSchema(data.serialized, TxProvingResult.schema);
-    },
-  };
-}
-
-/**
- * Serializer for the aztec_sendTx RPC method.
- * Handles serialization of transaction sending requests and transaction hash results between JSON-RPC format and native Aztec types.
- */
-export class AztecSendTxSerializer
-  implements
-    JSONRPCSerializer<
-      AztecWalletMethodMap['aztec_sendTx']['params'],
-      AztecWalletMethodMap['aztec_sendTx']['result']
-    >
-{
-  params = {
-    serialize: async (
-      method: string,
-      value: AztecWalletMethodMap['aztec_sendTx']['params'],
-    ): Promise<JSONRPCSerializedData> => {
-      const { tx } = value;
-      return {
-        method,
-        serialized: jsonStringify(tx),
-      };
-    },
-    deserialize: async (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): Promise<AztecWalletMethodMap['aztec_sendTx']['params']> => {
-      return { tx: await jsonParseWithSchema(data.serialized, Tx.schema) };
-    },
-  };
-
-  result = {
-    serialize: async (
-      method: string,
-      value: AztecWalletMethodMap['aztec_sendTx']['result'],
-    ): Promise<JSONRPCSerializedData> => {
-      return {
-        method,
-        serialized: jsonStringify(value),
-      };
-    },
-    deserialize: async (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): Promise<AztecWalletMethodMap['aztec_sendTx']['result']> => {
-      return await jsonParseWithSchema(data.serialized, TxHash.schema);
-    },
-  };
-}
-
-/**
- * Serializer for the aztec_getTxEffect RPC method.
- * Handles serialization of transaction effect queries and results between JSON-RPC format and native Aztec types.
- */
-export class AztecGetTxEffectSerializer
-  implements
-    JSONRPCSerializer<
-      AztecWalletMethodMap['aztec_getTxEffect']['params'],
-      AztecWalletMethodMap['aztec_getTxEffect']['result']
-    >
-{
-  params = {
-    serialize: async (
-      method: string,
-      value: AztecWalletMethodMap['aztec_getTxEffect']['params'],
-    ): Promise<JSONRPCSerializedData> => {
-      const { txHash } = value;
-      return {
-        method,
-        serialized: jsonStringify(txHash),
-      };
-    },
-    deserialize: async (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): Promise<AztecWalletMethodMap['aztec_getTxEffect']['params']> => {
-      const txHash = await jsonParseWithSchema(data.serialized, TxHash.schema);
-      return { txHash };
-    },
-  };
-
-  result = {
-    serialize: async (
-      method: string,
-      value: AztecWalletMethodMap['aztec_getTxEffect']['result'],
-    ): Promise<JSONRPCSerializedData> => {
-      return {
-        method,
-        serialized: jsonStringify(value),
-      };
-    },
-    deserialize: async (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): Promise<AztecWalletMethodMap['aztec_getTxEffect']['result']> => {
-      return await jsonParseWithSchema(data.serialized, inBlockSchemaFor(TxEffect.schema));
-    },
-  };
-}
-
-/**
- * Serializer for the aztec_getTxReceipt RPC method.
- * Handles serialization of transaction receipt queries and results between JSON-RPC format and native Aztec types.
- */
-export class AztecGetTxReceiptSerializer
-  implements
-    JSONRPCSerializer<
-      AztecWalletMethodMap['aztec_getTxReceipt']['params'],
-      AztecWalletMethodMap['aztec_getTxReceipt']['result']
-    >
-{
-  params = {
-    serialize: async (
-      method: string,
-      value: AztecWalletMethodMap['aztec_getTxReceipt']['params'],
-    ): Promise<JSONRPCSerializedData> => {
-      const { txHash } = value;
-      return {
-        method,
-        serialized: jsonStringify(txHash),
-      };
-    },
-    deserialize: async (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): Promise<AztecWalletMethodMap['aztec_getTxReceipt']['params']> => {
-      const txHash = await jsonParseWithSchema(data.serialized, TxHash.schema);
-      return { txHash };
-    },
-  };
-
-  result = {
-    serialize: async (method: string, value: TxReceipt): Promise<JSONRPCSerializedData> => {
-      return {
-        method,
-        serialized: jsonStringify(value),
-      };
-    },
-    deserialize: async (_method: string, data: JSONRPCSerializedData): Promise<TxReceipt> => {
-      return await jsonParseWithSchema(data.serialized, TxReceipt.schema);
-    },
-  };
-}
-
-/**
- * Serializer for the aztec_simulateTx RPC method.
- * Handles serialization of transaction simulation requests and results between JSON-RPC format and native Aztec types.
- */
-export class AztecSimulateTxSerializer
-  implements
-    JSONRPCSerializer<
-      AztecWalletMethodMap['aztec_simulateTx']['params'],
-      AztecWalletMethodMap['aztec_simulateTx']['result']
-    >
-{
-  params = {
-    serialize: async (
-      method: string,
-      value: AztecWalletMethodMap['aztec_simulateTx']['params'],
-    ): Promise<JSONRPCSerializedData> => {
-      const { txRequest, simulatePublic, msgSender, skipTxValidation, enforceFeePayment, profile } = value;
-      return {
-        method,
-        serialized: JSON.stringify({
-          txRequest: jsonStringify(txRequest),
-          simulatePublic,
-          msgSender: JSON.stringify(msgSender),
-          skipTxValidation,
-          enforceFeePayment,
-          profile,
-        }),
-      };
-    },
-    deserialize: async (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): Promise<AztecWalletMethodMap['aztec_simulateTx']['params']> => {
-      const { txRequest, simulatePublic, msgSender, skipTxValidation, enforceFeePayment, profile } =
-        JSON.parse(data.serialized);
-      return {
-        txRequest: await jsonParseWithSchema(txRequest, TxExecutionRequest.schema),
-        simulatePublic,
-        msgSender: await jsonParseWithSchema(msgSender, AztecAddress.schema),
-        skipTxValidation,
-        enforceFeePayment,
-        profile,
-      };
-    },
-  };
-
-  result = {
-    serialize: async (method: string, value: TxSimulationResult): Promise<JSONRPCSerializedData> => {
-      return {
-        method,
-        serialized: jsonStringify(value),
-      };
-    },
-    deserialize: async (_method: string, data: JSONRPCSerializedData): Promise<TxSimulationResult> => {
-      return await jsonParseWithSchema(data.serialized, TxSimulationResult.schema);
-    },
-  };
-}
-
-/**
- * Pre-instantiated serializer instances for each Aztec transaction-related RPC method.
- * These instances can be used directly by the RPC handler implementation.
- */
-export const aztecCreateTxExecutionRequestSerializer = new AztecCreateTxExecutionRequestSerializer();
-export const aztecProveTxSerializer = new AztecProveTxSerializer();
-export const aztecSendTxSerializer = new AztecSendTxSerializer();
-export const aztecGetTxEffectSerializer = new AztecGetTxEffectSerializer();
-export const aztecGetTxReceiptSerializer = new AztecGetTxReceiptSerializer();
-export const aztecSimulateTxSerializer = new AztecSimulateTxSerializer();

package/src/wallet.test.ts

@@ -1,275 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from 'vitest';
-import type { AccountWallet, PXE } from '@aztec/aztec.js';
-import { JSONRPCWalletClient } from '@walletmesh/router';
-import { AztecChainWallet } from './wallet.js';
-import { ContractArtifactCache } from './contractArtifactCache.js';
-import { AztecWalletError } from './errors.js';
-import type { JSONRPCTransport } from '@walletmesh/jsonrpc';
-import type { AztecWalletContext } from './types.js';
-
-describe('AztecChainWallet', () => {
-  let pxe: PXE;
-  let wallet: AccountWallet;
-  let transport: JSONRPCTransport;
-  let aztecWallet: AztecChainWallet;
-
-  beforeEach(() => {
-    // Mock PXE
-    pxe = {
-      // Add required PXE methods as needed
-    } as unknown as PXE;
-
-    // Mock AccountWallet
-    wallet = {
-      getAddress: vi.fn().mockResolvedValue('mockAddress'),
-    } as unknown as AccountWallet;
-
-    // Mock Transport
-    transport = {
-      send: vi.fn().mockResolvedValue(undefined),
-      on: vi.fn(),
-      off: vi.fn(),
-      emit: vi.fn(),
-    } as unknown as JSONRPCTransport;
-
-    // Create wallet instance
-    aztecWallet = new AztecChainWallet(pxe, wallet, transport);
-
-    // Setup fallback handler and serializer
-    const mockHandler = vi.fn().mockImplementation(async (context, method, _params) => {
-      if (!isAztecWalletContext(context)) {
-        throw new AztecWalletError('unknownInternalError', 'Invalid context');
-      }
-      if (method === 'aztec_getAccount') {
-        return await context.wallet.getAddress();
-      }
-      throw new AztecWalletError('invalidRequest', `Method not supported: ${method}`);
-    });
-
-    const mockSerializer = {
-      serialize: vi.fn().mockImplementation((value) => value),
-      deserialize: vi.fn().mockImplementation((value) => value),
-    };
-
-    Object.defineProperties(aztecWallet, {
-      fallbackHandler: {
-        value: mockHandler,
-        writable: true,
-        configurable: true,
-      },
-      fallbackSerializer: {
-        value: mockSerializer,
-        writable: true,
-        configurable: true,
-      },
-    });
-  });
-
-  describe('constructor', () => {
-    it('initializes with valid context', () => {
-      expect(aztecWallet).toBeInstanceOf(AztecChainWallet);
-      const context = (aztecWallet as unknown as { context: AztecWalletContext }).context;
-      expect(context.pxe).toBe(pxe);
-      expect(context.wallet).toBe(wallet);
-      expect(context.contractArtifactCache).toBeInstanceOf(ContractArtifactCache);
-    });
-
-    it('sets up fallback handler and serializer', () => {
-      const instance = aztecWallet as unknown as {
-        fallbackHandler: unknown;
-        fallbackSerializer: unknown;
-      };
-      expect(instance.fallbackHandler).toBeDefined();
-      expect(instance.fallbackSerializer).toBeDefined();
-    });
-
-    it('throws error when handler receives invalid context', async () => {
-      // Create a mock transport that simulates an error response
-      const mockSend = vi
-        .fn()
-        .mockRejectedValue(new AztecWalletError('unknownInternalError', 'Invalid context'));
-
-      const invalidTransport = {
-        send: mockSend,
-        on: vi.fn(),
-        off: vi.fn(),
-        emit: vi.fn(),
-      } as unknown as JSONRPCTransport;
-
-      // Create wallet with invalid context
-      new AztecChainWallet(null as unknown as PXE, null as unknown as AccountWallet, invalidTransport);
-
-      // Attempt to send a request
-      const request = {
-        jsonrpc: '2.0',
-        id: 1,
-        method: 'test_method',
-        params: [],
-      };
-
-      // Verify the error is thrown
-      await expect(mockSend(request)).rejects.toThrow(AztecWalletError);
-      expect(mockSend).toHaveBeenCalledWith(request);
-    });
-  });
-
-  describe('isAztecWalletContext', () => {
-    it('returns true for valid context', () => {
-      const validContext = {
-        pxe,
-        wallet,
-        contractArtifactCache: new ContractArtifactCache(wallet),
-      };
-      expect(isAztecWalletContext(validContext)).toBe(true);
-    });
-
-    it('returns false for null', () => {
-      expect(isAztecWalletContext(null)).toBe(false);
-    });
-
-    it('returns false for non-object values', () => {
-      expect(isAztecWalletContext(123)).toBe(false);
-      expect(isAztecWalletContext('string')).toBe(false);
-      expect(isAztecWalletContext(undefined)).toBe(false);
-      expect(isAztecWalletContext(true)).toBe(false);
-      expect(isAztecWalletContext([])).toBe(false);
-      expect(isAztecWalletContext(() => {})).toBe(false);
-    });
-
-    it('returns false for missing required properties', () => {
-      expect(isAztecWalletContext({})).toBe(false);
-      expect(isAztecWalletContext({ pxe })).toBe(false);
-      expect(isAztecWalletContext({ pxe, wallet })).toBe(false);
-      expect(isAztecWalletContext({ wallet, contractArtifactCache: new ContractArtifactCache(wallet) })).toBe(
-        false,
-      );
-    });
-
-    it('returns false for objects with null properties', () => {
-      expect(isAztecWalletContext({ pxe: null, wallet: null, contractArtifactCache: null })).toBe(false);
-      expect(
-        isAztecWalletContext({ pxe, wallet: null, contractArtifactCache: new ContractArtifactCache(wallet) }),
-      ).toBe(false);
-      expect(
-        isAztecWalletContext({ pxe: null, wallet, contractArtifactCache: new ContractArtifactCache(wallet) }),
-      ).toBe(false);
-    });
-  });
-
-  describe('asWalletRouterClient', () => {
-    it('returns a JSONRPCWalletClient instance', () => {
-      const client = aztecWallet.asWalletRouterClient();
-      expect(client).toBeInstanceOf(JSONRPCWalletClient);
-    });
-
-    it('returns a valid router client', () => {
-      const client = aztecWallet.asWalletRouterClient();
-      // Verify the client is properly instantiated
-      expect(client).toBeDefined();
-      expect(client).toBeInstanceOf(JSONRPCWalletClient);
-    });
-  });
-
-  describe('request handling', () => {
-    it('handles valid context in fallback handler', async () => {
-      const result = await (
-        aztecWallet as unknown as {
-          fallbackHandler: (
-            context: AztecWalletContext,
-            method: string,
-            params: unknown[],
-          ) => Promise<unknown>;
-        }
-      ).fallbackHandler(
-        {
-          pxe,
-          wallet,
-          contractArtifactCache: new ContractArtifactCache(wallet),
-        },
-        'aztec_getAccount',
-        [],
-      );
-      expect(result).toBe('mockAddress');
-    });
-
-    it('throws error for invalid context in fallback handler', async () => {
-      await expect(
-        (
-          aztecWallet as unknown as {
-            fallbackHandler: (
-              context: AztecWalletContext,
-              method: string,
-              params: unknown[],
-            ) => Promise<unknown>;
-          }
-        ).fallbackHandler({ invalidContext: true } as unknown as AztecWalletContext, 'aztec_getAccount', []),
-      ).rejects.toThrow(AztecWalletError);
-    });
-  });
-
-  describe('message handling', () => {
-    it('processes incoming messages through transport', async () => {
-      const message = {
-        jsonrpc: '2.0',
-        id: 1,
-        method: 'aztec_getAccount',
-        params: [],
-      };
-
-      // Setup request handler to use fallback handler
-      const handleRequest = async (msg: unknown) => {
-        const typedMessage = msg as { method: string; params: unknown[] };
-        return (
-          aztecWallet as unknown as {
-            fallbackHandler: (
-              context: AztecWalletContext,
-              method: string,
-              params: unknown[],
-            ) => Promise<unknown>;
-          }
-        ).fallbackHandler(
-          { pxe, wallet, contractArtifactCache: new ContractArtifactCache(wallet) },
-          typedMessage.method,
-          typedMessage.params,
-        );
-      };
-
-      (aztecWallet as unknown as { handleRequest: typeof handleRequest }).handleRequest = handleRequest;
-
-      await handleRequest(message);
-      expect(wallet.getAddress).toHaveBeenCalled();
-    });
-
-    it('handles transport errors gracefully', async () => {
-      const message = {
-        jsonrpc: '2.0',
-        id: 1,
-        method: 'invalidMethod',
-        params: [],
-      };
-
-      // Setup request handler to throw error for invalid method
-      const handleRequest = async (_msg: unknown) => {
-        throw new AztecWalletError('invalidRequest', 'Invalid method');
-      };
-
-      (aztecWallet as unknown as { handleRequest: typeof handleRequest }).handleRequest = handleRequest;
-
-      await expect(handleRequest(message)).rejects.toThrow(AztecWalletError);
-    });
-  });
-});
-
-// Helper function to check context type
-function isAztecWalletContext(value: unknown): value is AztecWalletContext {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    'pxe' in value &&
-    'wallet' in value &&
-    'contractArtifactCache' in value &&
-    value.pxe !== null &&
-    value.wallet !== null &&
-    value.contractArtifactCache !== null
-  );
-}