@hashgraph/hedera-wallet-connect 2.0.0-canary.811af2f.0 → 2.0.1-canary.0769c48.0

package/README.md

@@ -1,36 +1,119 @@
-# Overview
+# Background
 
-Hedera is a public distributed ledger that is EVM compatible. This library provides tools to
-integrate Hedera using Reown's AppKit and WalletKit.
+This library provides tools and recommendations on how to integrate Hedera into an application
+that requires communication with a wallet that supports Hedera. There are 2 different paths to
+integrate Hedera in this context. Both approaches use the
+[WalletConnect](https://walletconnect.network/) network to send messages from apps to wallets
+and back.
 
-There are 2 distict paths to integrate Hedera. Hedera natively operates using a gRPC based API
-for write transactions and a REST API for read transactions. To acheive EVM compatibility, there
-is a software middlelayer called the Hedera JSON-RPC Relay that translates Ethereum JSON-RPC
-compatible API calls into the Hedera gRPC and REST API calls.
+## Hedera APIs
+
+Hedera natively operates using a gRPC API for write transactions and by default, a REST API for
+read transactions. Hedera implements EVM compatible smart contracts using
+[Hyperledger Besu](https://besu.hyperledger.org/) under the hood.
+
+Ethereum developers and toolsets often expect to interact with Ethereum compatible chains using
+the [Ethereum JSON-RPC](https://ethereum.org/en/developers/docs/apis/json-rpc/). To acheive
+compatibility with this API,
+[Hedera JSON-RPC Providers](https://docs.hedera.com/hedera/core-concepts/smart-contracts/json-rpc-relay#community-hosted-json-rpc-relays)
+operate a software middlelayer that translates Ethereum JSON-RPC compatible API calls into
+Hedera gRPC and REST API calls.
+
+## Ethereum JSON-RPC vs. Hedera JSON-RPC vs. Hedera JSON-RPC Relay
 
 When integrating, app developers can choose to use the Hedera native approach and send
-transactions to wallets over the WalletConnect relays using the JSON-RPC spec defined for Hedera
-native transactions or use Ethereum JSON-RPC calls sent to a Hedera JSON-RPC provider which then
-communicates with Hedera consensus and mirror nodes.
+transactions to wallets over the WalletConnect network using the JSON-RPC spec defined for
+Hedera native transactions or use Ethereum JSON-RPC calls sent to a Hedera JSON-RPC Relay
+provider which then communicates with Hedera consensus and mirror nodes.
 
-In short, JSON-RPC is a type of API stucture, such as SOAP, gRPC, REST, GraphQL, etc. In the
-Hedera ecosystem, there are distinct concepts regarding JSON-RPC APIs to consider:
+On a high level, JSON-RPC is a type of API stucture, such as SOAP, gRPC, REST, GraphQL, etc. In
+the Hedera ecosystem, there are distinct concepts regarding JSON-RPC APIs to consider:
 
 - Ethereum JSON-RPC spec defines how to interact with Ethereum compatible networks
 - Hedera JSON-RPC Relay implements the Ethereum JSON-RPC spec for Hedera
-- Wallets in the Hedera ecosystem support a separate JSON-RPC spec that defines how to send
-  transactions to wallets over the WalletConnect relays. This is a Hedera specific spec that is
-  not compatible with the Ethereum JSON-RPC spec, rather is used to interact with the Hedera
-  network without the JSON-RPC Relay.
+- Wallets in the Hedera ecosystem also support a separate specification that defines how to send
+  transactions and messages to wallets over the WalletConnect network without relying on a
+  Hedera JSON-RPC Relay provider. This is a Hedera specific specification defined for utilizing
+  the WalletConnect network distict from other JSON-RPC specs such as the one defined by the
+  Ethereum network.
 
 For more information see:
 
 - [Ethereum JSON-RPC Specification ](https://ethereum.github.io/execution-apis/api-documentation/)
-- [Hedera EVM: JSON-RPC relay](https://docs.hedera.com/hedera/core-concepts/smart-contracts/json-rpc-relay)
-- [Hedera Native: JSON-RPC spec](https://docs.reown.com/advanced/multichain/rpc-reference/hedera-rpc).
-- [@hashgraph/sdk](https://www.npmjs.com/package/@hashgraph/sdk)
+- [Hedera JSON-RPC relay](https://docs.hedera.com/hedera/core-concepts/smart-contracts/json-rpc-relay)
+- [Hedera Native JSON-RPC spec for WalletConnect](https://docs.reown.com/advanced/multichain/rpc-reference/hedera-rpc)
+- [Hedera Javascript SDK](https://www.npmjs.com/package/@hashgraph/sdk)
+- [Reown Docs](https://docs.reown.com/overview)
+- [WalletConnect Network](https://walletconnect.network/)
+
+# Getting started
+
+In addition to choosing between the Hedera native JSON-RPC spec and the Ethereum JSON-RPC spec,
+when building with javascript/typescript, there are 2 supported options to utilize the
+WalletConnect network to send information from apps to wallets and back.
+
+This README assumes an understanding of Hedera as well as the WalletConnect network and focusses
+on how to send a payload to a wallet for processing and presentation to an end user that is a
+Hedera account holder. We recommend reviewing the [Hedera Docs](https://docs.hedera.com/) and
+first submitting transactions directly to the Hedera network without requiring interaction with
+a [Wallet](#hedera-wallets) when integrating Hedera for the first time. We also recommend
+reviewing the [Reown docs](https://docs.reown.com/overview).
+
+## Using this library and underlying WalletConnect libraries directly
+
+1. Add Hedera dependencies to your project:
+
+```sh
+npm install @hashgraph/hedera-wallet-connect@2.0.0-canary.811af2f.0 @hashgraph/sdk @walletconnect/modal
+```
 
-## Getting started
+2. Initialize dApp Connector
+
+```typescript
+import {
+  HederaSessionEvent,
+  HederaJsonRpcMethod,
+  DAppConnector,
+  HederaChainId,
+} from '@hashgraph/hedera-wallet-connect'
+import { LedgerId } from '@hashgraph/sdk'
+
+const metadata = {
+  name: 'Hedera Integration using Hedera DAppConnector - v1 approach',
+  description: 'Hedera dAppConnector Example',
+  url: 'https://example.com', // origin must match your domain & subdomain
+  icons: ['https://avatars.githubusercontent.com/u/31002956'],
+}
+
+const dAppConnector = new DAppConnector(
+  metadata,
+  LedgerId.Mainnet,
+  projectId,
+  Object.values(HederaJsonRpcMethod),
+  [HederaSessionEvent.ChainChanged, HederaSessionEvent.AccountsChanged],
+  [HederaChainId.Mainnet, HederaChainId.Testnet],
+)
+
+await dAppConnector.init({ logger: 'error' })
+```
+
+3. Connect to a wallet
+
+```typescript
+await dAppConnector.openModal()
+```
+
+4. Handle sessions, events, and payloads.
+
+- See: [DAppConnector](./src/lib/dapp/index.ts)
+
+### Examples, demos, and tools
+
+- [Hashgraph React Wallets by Buidler Labs](https://github.com/buidler-labs/hashgraph-react-wallets)
+- [Hashgraph Online's WalletConnect SDK](https://github.com/hashgraph-online/hashinal-wc)
+- <em>[Add an example, demo, or tool here](https://github.com/hashgraph/hedera-wallet-connect/pulls)</em>
+
+## Using Reown's AppKit
 
 1. Follow one of the quickstart instructions at
    https://docs.reown.com/appkit/overview#quickstart
@@ -38,7 +121,7 @@ For more information see:
 2. Add Hedera dependencies to your project:
 
 ```sh
-npm install file:../../hedera-wallet-connect @hashgraph/sdk @walletconnect/universal-provider
+npm install @hashgraph/hedera-wallet-connect@2.0.1-canary.24fffa7.0 @hashgraph/sdk @walletconnect/universal-provider
 ```
 
 3. Update `createAppKit` with adapters and a universal provider for Hedera. Note the
@@ -122,8 +205,34 @@ createAppKit({
 })
 ```
 
-## Examples and Demos
+### Examples, demos, and tools
 
-- [Example App by Hgraph](https://github.com/hgraph-io/hedera-app)
-- [Example Wallet by Hgraph](https://github.com/hgraph-io/hedera-wallet)
-- [Hashgraph React Wallets by Buidler Labs](https://github.com/buidler-labs/hashgraph-react-wallets)
+- [Hedera App Example by Hgraph](https://github.com/hgraph-io/hedera-app)
+- [Hedera Wallet Example by Hgraph](https://github.com/hgraph-io/hedera-wallet)
+- <em>[Add an example, demo, or tool here](https://github.com/hashgraph/hedera-wallet-connect/pulls)</em>
+
+# Hedera Wallets
+
+- [Hashpack](https://hashpack.app/)
+- [Kabila](https://wallet.kabila.app/)
+- [Blade](https://bladewallet.io/)
+- [Dropp](https://dropp.cc/)
+
+# Upgrading from v1 to v2
+
+Upgrading from v1 to v2 should be fairly straightforward. We have maintained compatibility with
+the v1 structure, while deprecating a few methods marked as deprecated. The v1 library did not
+explicitly offer support for Ethereum JSON-RPC function calls, so the only breaking changes
+refer to how to send transactions to wallets using the `hedera:(mainnet|testnet)` namespace.
+While minimal, the main breaking changes are:
+
+- remove WalletConnect v1 modals
+
+  - these are very old, though in the spirit of semver, we kept the dependency until this
+    library's v2 release
+
+- remove setting node id's within this library for transactions
+
+  - initially, a transaction created by the Hedera Javascript SDK needed to have one or more
+    consensus node ids set to be able to serialize into bytes, sent over a network, and
+    deserialized by the SDK

package/dist/lib/dapp/index.d.ts

@@ -11,6 +11,7 @@ export { SessionNotFoundError } from './SessionNotFoundError';
 type BaseLogger = 'error' | 'warn' | 'info' | 'debug' | 'trace' | 'fatal';
 export declare class DAppConnector {
     private logger;
+    readonly storagePrefix = "hedera-wc/dapp-connector/";
     dAppMetadata: SignClientTypes.Metadata;
     network: LedgerId;
     projectId: string;
@@ -23,7 +24,6 @@ export declare class DAppConnector {
     walletConnectModal: WalletConnectModal;
     signers: DAppSigner[];
     isInitializing: boolean;
-    private storagePrefix;
     /**
      * Initializes the DAppConnector instance.
      * @param metadata - SignClientTypes.Metadata object for the DApp metadata.
@@ -194,7 +194,9 @@ export declare class DAppConnector {
      *
      * @param {SignTransactionParams} params - The parameters of type {@link SignTransactionParams | `SignTransactionParams`} required for `Transaction` signing.
      * @param {string} params.signerAccountId - a signer Hedera Account identifier in {@link https://hips.hedera.com/hip/hip-30 | HIP-30} (`<nework>:<shard>.<realm>.<num>`) form.
-     * @param {Transaction} params.transactionBody - a Transaction object built with the @hashgraph/sdk
+     * @param {Transaction | string} params.transactionBody - a built Transaction object, or a base64 string of a transaction body( HIP-820).
+     * HIP-820 calls for a base64 encoded proto.TransactionBody and many wallets support a serialized Transaction object generated by the Hedera Javascript SDK.
+     * Both options are supported here for backwards compatibility.
      * @returns Promise\<{@link SignTransactionResult}\>
      * @example
      * ```ts

package/dist/lib/dapp/index.js

@@ -39,6 +39,7 @@ export class DAppConnector {
      * @param logLevel - Logging level for the DAppConnector (optional).
      */
     constructor(metadata, network, projectId, methods, events, chains, logLevel = 'debug') {
+        this.storagePrefix = 'hedera-wc/dapp-connector/';
         this.network = LedgerId.TESTNET;
         this.supportedMethods = [];
         this.supportedEvents = [];
@@ -47,7 +48,6 @@ export class DAppConnector {
         this.onSessionIframeCreated = null;
         this.signers = [];
         this.isInitializing = false;
-        this.storagePrefix = 'hedera-wc/dapp-connector/';
         this.abortableConnect = async (callback) => {
             return new Promise(async (resolve, reject) => {
                 const pairTimeoutMs = 480000;
@@ -501,7 +501,9 @@ export class DAppConnector {
      *
      * @param {SignTransactionParams} params - The parameters of type {@link SignTransactionParams | `SignTransactionParams`} required for `Transaction` signing.
      * @param {string} params.signerAccountId - a signer Hedera Account identifier in {@link https://hips.hedera.com/hip/hip-30 | HIP-30} (`<nework>:<shard>.<realm>.<num>`) form.
-     * @param {Transaction} params.transactionBody - a Transaction object built with the @hashgraph/sdk
+     * @param {Transaction | string} params.transactionBody - a built Transaction object, or a base64 string of a transaction body( HIP-820).
+     * HIP-820 calls for a base64 encoded proto.TransactionBody and many wallets support a serialized Transaction object generated by the Hedera Javascript SDK.
+     * Both options are supported here for backwards compatibility.
      * @returns Promise\<{@link SignTransactionResult}\>
      * @example
      * ```ts

package/dist/lib/shared/payloads.d.ts

@@ -84,7 +84,7 @@ export interface SignAndExecuteTransactionResponse extends EngineTypes.RespondPa
 }
 export interface SignTransactionParams {
     signerAccountId: string;
-    transactionBody: Transaction;
+    transactionBody: Transaction | string;
 }
 export interface SignTransactionRequest extends EngineTypes.RequestParams {
     request: {

package/dist/lib/shared/utils.d.ts

@@ -4,7 +4,7 @@ import { proto } from '@hashgraph/proto';
 /**
  * Converts `Transaction` to a Base64-string.
  *
- * Converts a transaction to bytes and then encodes it as a Base64-string. Allow uncompleted transaction (HIP-745).
+ * Converts a transaction to bytes and then encodes it as a Base64-string. Allow incomplete transaction (HIP-745).
  * @param transaction - Any instance of a class that extends `Transaction`
  * @returns Base64 encoded representation of the input `Transaction` object
  */
@@ -29,9 +29,10 @@ export declare function transactionToBase64String<T extends Transaction>(transac
 export declare function base64StringToTransaction<T extends Transaction>(transactionBytes: string): T;
 /**
  * @param transaction - a base64 encoded string of proto.TransactionBody.encode().finish()
+ * @param nodeAccountId - an optional `AccountId` to set the node account ID for the transaction
  * @returns `string`
  * */
-export declare function transactionToTransactionBody<T extends Transaction>(transaction: T): any;
+export declare function transactionToTransactionBody<T extends Transaction>(transaction: T, nodeAccountId?: AccountId | null): proto.ITransactionBody;
 export declare function transactionBodyToBase64String(transactionBody: proto.ITransactionBody): string;
 /**
  * @param transactionList - a proto.TransactionList object

package/dist/lib/shared/utils.js

@@ -23,7 +23,7 @@ import { proto } from '@hashgraph/proto';
 /**
  * Converts `Transaction` to a Base64-string.
  *
- * Converts a transaction to bytes and then encodes it as a Base64-string. Allow uncompleted transaction (HIP-745).
+ * Converts a transaction to bytes and then encodes it as a Base64-string. Allow incomplete transaction (HIP-745).
  * @param transaction - Any instance of a class that extends `Transaction`
  * @returns Base64 encoded representation of the input `Transaction` object
  */
@@ -54,12 +54,13 @@ export function base64StringToTransaction(transactionBytes) {
 }
 /**
  * @param transaction - a base64 encoded string of proto.TransactionBody.encode().finish()
+ * @param nodeAccountId - an optional `AccountId` to set the node account ID for the transaction
  * @returns `string`
  * */
-export function transactionToTransactionBody(transaction) {
+export function transactionToTransactionBody(transaction, nodeAccountId = null) {
     // This is a private function, though provides the capabilities to construct a proto.TransactionBody
     //@ts-ignore
-    return transaction._makeTransactionBody(null);
+    return transaction._makeTransactionBody(nodeAccountId);
 }
 export function transactionBodyToBase64String(transactionBody) {
     return Uint8ArrayToBase64String(proto.TransactionBody.encode(transactionBody).finish());

package/dist/reown/adapter.js

@@ -28,7 +28,7 @@ export class HederaAdapter extends AdapterBlueprint {
     setUniversalProvider(universalProvider) {
         this.addConnector(new HederaConnector({
             provider: universalProvider,
-            caipNetworks: this.caipNetworks || [],
+            caipNetworks: this.getCaipNetworks() || [],
             namespace: this.namespace,
         }));
     }

package/dist/reown/providers/EIP155Provider.d.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'events';
-import Client from '@walletconnect/universal-provider/node_modules/@walletconnect/sign-client';
+import Client from '@walletconnect/sign-client';
 import { SessionTypes } from '@walletconnect/types';
 import { IProvider, SessionNamespace, RpcProvidersMap, RequestParams, Namespace } from '@walletconnect/universal-provider';
 declare class EIP155Provider implements IProvider {

package/dist/reown/wallets/EIP155Wallet.js

@@ -28,7 +28,6 @@ export class EIP155Wallet {
         return this.eth_signTypedData(domain, types, data);
     }
     async eth_signTransaction(transaction, provider) {
-        console.log({ transaction });
         // Populate transaction
         const preparedTransaction = await this.connect(provider).populateTransaction(transaction);
         delete preparedTransaction.from;
@@ -68,11 +67,9 @@ export class EIP155Wallet {
                     return formatJsonRpcResult(id, signedMessage);
                 }
                 catch (error) {
-                    console.error(error);
                     if (!(error instanceof Error)) {
                         return formatJsonRpcError(id, 'Failed to sign message');
                     }
-                    alert(error.message);
                     return formatJsonRpcError(id, error.message);
                 }
             case Eip155JsonRpcMethod.SignTypedData:
@@ -86,11 +83,9 @@ export class EIP155Wallet {
                     return formatJsonRpcResult(id, signedData);
                 }
                 catch (error) {
-                    console.error(error);
                     if (!(error instanceof Error)) {
                         return formatJsonRpcError(id, 'Failed to sign typed data');
                     }
-                    alert(error.message);
                     return formatJsonRpcError(id, error.message);
                 }
             case Eip155JsonRpcMethod.SendRawTransaction:
@@ -100,14 +95,9 @@ export class EIP155Wallet {
                     const sendTransaction = request.params[0];
                     const txResponse = await this[request.method](sendTransaction, provider);
                     const txHash = typeof txResponse === 'string' ? txResponse : txResponse === null || txResponse === void 0 ? void 0 : txResponse.hash;
-                    const txReceipt = await txResponse.wait();
-                    console.log(`Transaction broadcasted on chain ${chainId} , ${{
-                        txHash,
-                    }}, status: ${txReceipt === null || txReceipt === void 0 ? void 0 : txReceipt.status}`);
                     return formatJsonRpcResult(id, txHash);
                 }
                 catch (error) {
-                    console.error(error);
                     return formatJsonRpcError(id, error instanceof Error ? error.message : 'Failed to send transaction');
                 }
             case Eip155JsonRpcMethod.SignTransaction:
@@ -118,11 +108,9 @@ export class EIP155Wallet {
                     return formatJsonRpcResult(id, signature);
                 }
                 catch (error) {
-                    console.error(error);
                     if (!(error instanceof Error)) {
                         return formatJsonRpcError(id, 'Failed to sign transaction');
                     }
-                    alert(error.message);
                     return formatJsonRpcError(id, error.message);
                 }
             default:

package/dist/reown/wallets/HIP820Wallet.d.ts

@@ -1,11 +1,11 @@
-import { Wallet as HederaWallet, AccountId, Transaction, Query } from '@hashgraph/sdk';
+import { Wallet as HederaWallet, AccountId, Transaction, Query, PrivateKey } from '@hashgraph/sdk';
 import { JsonRpcError, JsonRpcResult } from '@walletconnect/jsonrpc-utils';
 import { HederaChainId, HederaJsonRpcMethod, GetNodeAddressesResult, ExecuteTransactionResult, SignAndExecuteQueryResult, SignMessageResult, SignAndExecuteTransactionResult, SignTransactionResult, WalletRequestEventArgs } from '../..';
 import Provider from '../../lib/wallet/provider';
 interface IInitArgs {
     chainId: HederaChainId;
     accountId: AccountId | string;
-    privateKey: string;
+    privateKey: PrivateKey;
     _provider?: Provider;
 }
 export interface HIP820WalletInterface {

package/dist/reown/wallets/HIP820Wallet.js

@@ -1,6 +1,6 @@
 import { Buffer } from 'buffer';
 import { getSdkError } from '@walletconnect/utils';
-import { Wallet as HederaWallet, Client, AccountId, PrecheckStatusError, PrivateKey, } from '@hashgraph/sdk';
+import { Wallet as HederaWallet, Client, AccountId, PrecheckStatusError, } from '@hashgraph/sdk';
 import { proto } from '@hashgraph/proto';
 import { formatJsonRpcError, formatJsonRpcResult, } from '@walletconnect/jsonrpc-utils';
 import { HederaJsonRpcMethod, base64StringToQuery, Uint8ArrayToBase64String, stringToSignerMessage, signerSignaturesToSignatureMap, getHederaError, base64StringToTransaction, signatureMapToBase64String, } from '../..';
@@ -22,7 +22,7 @@ export class HIP820Wallet {
         const network = chainId.split(':')[1];
         const client = Client.forName(network);
         const provider = _provider !== null && _provider !== void 0 ? _provider : new Provider(client);
-        const wallet = new HederaWallet(accountId, PrivateKey.fromStringECDSA(privateKey), provider);
+        const wallet = new HederaWallet(accountId, privateKey, provider);
         return new HIP820Wallet(wallet);
     }
     /*
@@ -118,7 +118,6 @@ export class HIP820Wallet {
     async approveSessionRequest(event) {
         const { method, id, body } = this.parseSessionRequest(event);
         const response = await this[method](id, body);
-        console.log({ response });
         return response;
     }
     rejectSessionRequest(requestEvent) {
@@ -134,7 +133,6 @@ export class HIP820Wallet {
     _) {
         const nodesAccountIds = this.wallet.getNetwork();
         const nodes = Object.values(nodesAccountIds).map((nodeAccountId) => nodeAccountId.toString());
-        console.log(nodes);
         return formatJsonRpcResult(id, {
             nodes,
         });
@@ -142,7 +140,7 @@ export class HIP820Wallet {
     // 2. hedera_executeTransaction
     async hedera_executeTransaction(id, signedTransaction) {
         try {
-            const response = await signedTransaction.executeWithSigner(this.wallet);
+            const response = await this.wallet.call(signedTransaction);
             return formatJsonRpcResult(id, response.toJSON());
         }
         catch (e) {
@@ -203,7 +201,6 @@ export class HIP820Wallet {
     }
     // 5. hedera_signAndExecuteTransaction
     async hedera_signAndExecuteTransaction(id, transaction) {
-        console.log({ inputTx: JSON.parse(JSON.stringify(transaction)) });
         // check transaction is incomplete (HIP-745)
         if (!transaction.isFrozen()) {
             // set multiple nodeAccountIds and transactionId if not present

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hashgraph/hedera-wallet-connect",
-  "version": "2.0.0-canary.811af2f.0",
-  "description": "A library to facilitate integrating Hedera",
+  "version": "2.0.1-canary.0769c48.0",
+  "description": "A library to facilitate integrating Hedera with WalletConnect",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/hashgraph/hedera-wallet-connect.git"
@@ -14,31 +14,30 @@
     "walletconnect",
     "reown",
     "hashgraph",
-    "evm",
-    "ethereum",
-    "smart contracts",
     "hbar",
-    "ethers"
+    "evm",
+    "smart contracts"
   ],
   "license": "Apache-2.0",
   "scripts": {
     "build": "rimraf dist && tsc",
     "watch": "nodemon --watch src/ --ext ts --exec \"npm run build\"",
-    "test": "jest",
-    "prepublishOnly": "rm -Rf dist && npm run build",
+    "test": "jest --coverage",
+    "prepublishOnly": "rm -Rf dist && npm run test && npm run build",
     "prettier:check": "prettier --check ./src/",
     "prettier:fix": "prettier --write ./src/"
   },
   "peerDependencies": {
-    "@hashgraph/sdk": "^2.61.0",
-    "@reown/appkit": "^1.7.1",
-    "@reown/walletkit": "^1.2.3",
+    "@hashgraph/sdk": "^2.63.0",
+    "@reown/appkit": "1.7.3",
+    "@reown/walletkit": "1.2.3",
     "@walletconnect/modal": "^2.7.0",
     "ethers": "^6.13.5"
   },
   "devDependencies": {
     "@swc/jest": "^0.2.37",
-    "jest": "^29.7.0",
+    "@types/jest": "^30.0.0",
+    "jest": "^30.0.3",
     "prettier": "^3.5.3",
     "ts-node": "^10.9.2",
     "typescript": "^5.8.2"