@hashgraph/hedera-wallet-connect 1.3.8-canary.e8b789d.0 → 1.3.8-canary.ea19d34.0

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

@@ -1,5 +1,6 @@
 import { Signer, AccountBalance, AccountId, AccountInfo, Executable, Key, LedgerId, SignerSignature, Transaction, TransactionRecord } from '@hashgraph/sdk';
 import type { CoreTypes, ISignClient } from '@walletconnect/types';
+import { LogLevel } from '../shared/logger';
 export declare class DAppSigner implements Signer {
     private readonly accountId;
     private readonly signClient;
@@ -7,12 +8,12 @@ export declare class DAppSigner implements Signer {
     private readonly ledgerId;
     readonly extensionId?: string | undefined;
     private logger;
-    constructor(accountId: AccountId, signClient: ISignClient, topic: string, ledgerId?: LedgerId, extensionId?: string | undefined, logLevel?: 'error' | 'warn' | 'info' | 'debug');
+    constructor(accountId: AccountId, signClient: ISignClient, topic: string, ledgerId?: LedgerId, extensionId?: string | undefined, logLevel?: LogLevel);
     /**
      * Sets the logging level for the DAppSigner
      * @param level - The logging level to set
      */
-    setLogLevel(level: 'error' | 'warn' | 'info' | 'debug'): void;
+    setLogLevel(level: LogLevel): void;
     private _getHederaClient;
     private get _signerAccountId();
     private _getRandomNodes;
@@ -31,7 +32,9 @@ export declare class DAppSigner implements Signer {
     getAccountInfo(): Promise<AccountInfo>;
     getAccountRecords(): Promise<TransactionRecord[]>;
     getMetadata(): CoreTypes.Metadata;
-    sign(data: Uint8Array[], signOptions?: Record<string, any>): Promise<SignerSignature[]>;
+    sign(data: Uint8Array[], signOptions?: {
+        encoding?: 'utf-8' | 'base64';
+    }): Promise<SignerSignature[]>;
     checkTransaction<T extends Transaction>(transaction: T): Promise<T>;
     populateTransaction<T extends Transaction>(transaction: T): Promise<T>;
     /**

package/dist/lib/dapp/DAppSigner.js

@@ -19,8 +19,9 @@
  */
 import { AccountBalance, AccountId, AccountInfo, LedgerId, SignerSignature, Transaction, TransactionRecord, Client, PublicKey, TransactionId, TransactionResponse, Query, AccountRecordsQuery, AccountInfoQuery, AccountBalanceQuery, TransactionReceiptQuery, TransactionReceipt, TransactionRecordQuery, } from '@hashgraph/sdk';
 import { proto } from '@hashgraph/proto';
-import { HederaJsonRpcMethod, Uint8ArrayToBase64String, base64StringToSignatureMap, base64StringToUint8Array, ledgerIdToCAIPChainId, queryToBase64String, transactionBodyToBase64String, transactionToBase64String, transactionToTransactionBody, extensionOpen, } from '../shared';
+import { HederaJsonRpcMethod, base64StringToSignatureMap, base64StringToUint8Array, ledgerIdToCAIPChainId, queryToBase64String, transactionBodyToBase64String, transactionToBase64String, transactionToTransactionBody, extensionOpen, Uint8ArrayToBase64String, Uint8ArrayToString, } from '../shared';
 import { DefaultLogger } from '../shared/logger';
+import { SessionNotFoundError } from './SessionNotFoundError';
 const clients = {};
 export class DAppSigner {
     constructor(accountId, signClient, topic, ledgerId = LedgerId.MAINNET, extensionId, logLevel = 'debug') {
@@ -60,6 +61,21 @@ export class DAppSigner {
         return allNodes.slice(0, numberOfNodes);
     }
     request(request) {
+        var _a, _b;
+        // Avoid a wallet call if the session is no longer valid
+        if (!((_b = (_a = this === null || this === void 0 ? void 0 : this.signClient) === null || _a === void 0 ? void 0 : _a.session) === null || _b === void 0 ? void 0 : _b.get(this.topic))) {
+            this.logger.error('Session no longer exists, signer will be removed. Please reconnect to the wallet.');
+            // Notify DAppConnector to remove this signer
+            this.signClient.emit({
+                topic: this.topic,
+                event: {
+                    name: 'session_delete',
+                    data: { topic: this.topic },
+                },
+                chainId: ledgerIdToCAIPChainId(this.ledgerId),
+            });
+            throw new SessionNotFoundError('Session no longer exists. Please reconnect to the wallet.');
+        }
         if (this.extensionId)
             extensionOpen(this.extensionId);
         return this.signClient.request({
@@ -95,14 +111,18 @@ export class DAppSigner {
     getMetadata() {
         return this.signClient.metadata;
     }
-    async sign(data, signOptions) {
-        this.logger.debug('Signing data');
+    async sign(data, signOptions = {
+        encoding: 'utf-8',
+    }) {
         try {
+            const messageToSign = signOptions.encoding === 'base64'
+                ? Uint8ArrayToBase64String(data[0])
+                : Uint8ArrayToString(data[0]);
             const { signatureMap } = await this.request({
                 method: HederaJsonRpcMethod.SignMessage,
                 params: {
                     signerAccountId: this._signerAccountId,
-                    message: Uint8ArrayToBase64String(data[0]),
+                    message: messageToSign,
                 },
             });
             const sigmap = base64StringToSignatureMap(signatureMap);
@@ -230,9 +250,7 @@ export class DAppSigner {
                 if (!(result === null || result === void 0 ? void 0 : result.error)) {
                     return { result: result.result };
                 }
-                else {
-                    this.logger.error('Error executing free receipt query. Sending to wallet.', result.error);
-                }
+                this.logger.error('Error executing free receipt query. Sending to wallet.', result.error);
             }
             /**
              * Note, should we be converting these to specific query types?
@@ -253,6 +271,7 @@ export class DAppSigner {
             return { result: this._parseQueryResponse(query, result.response) };
         }
         catch (error) {
+            this.logger.error('Error executing query request:', error);
             return { error };
         }
     }

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

@@ -0,0 +1,3 @@
+export declare class SessionNotFoundError extends Error {
+    constructor(message: string);
+}

package/dist/lib/dapp/SessionNotFoundError.js

@@ -0,0 +1,6 @@
+export class SessionNotFoundError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SessionNotFoundError';
+    }
+}

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

@@ -2,9 +2,11 @@ import { AccountId, LedgerId } from '@hashgraph/sdk';
 import { SessionTypes, SignClientTypes } from '@walletconnect/types';
 import { WalletConnectModal } from '@walletconnect/modal';
 import SignClient from '@walletconnect/sign-client';
+import { LogLevel } from '../shared/logger';
 import { GetNodeAddressesResult, ExecuteTransactionParams, ExecuteTransactionResult, SignMessageParams, SignMessageResult, SignAndExecuteQueryResult, SignAndExecuteQueryParams, SignAndExecuteTransactionParams, SignAndExecuteTransactionResult, SignTransactionParams, SignTransactionResult, ExtensionData } from '../shared';
 import { DAppSigner } from './DAppSigner';
 export * from './DAppSigner';
+export { SessionNotFoundError } from './SessionNotFoundError';
 type BaseLogger = 'error' | 'warn' | 'info' | 'debug' | 'trace' | 'fatal';
 export declare class DAppConnector {
     private logger;
@@ -30,12 +32,12 @@ export declare class DAppConnector {
      * @param chains - Array of supported chains for the DApp (optional).
      * @param logLevel - Logging level for the DAppConnector (optional).
      */
-    constructor(metadata: SignClientTypes.Metadata, network: LedgerId, projectId: string, methods?: string[], events?: string[], chains?: string[], logLevel?: 'error' | 'warn' | 'info' | 'debug');
+    constructor(metadata: SignClientTypes.Metadata, network: LedgerId, projectId: string, methods?: string[], events?: string[], chains?: string[], logLevel?: LogLevel);
     /**
      * Sets the logging level for the DAppConnector
      * @param level - The logging level to set
      */
-    setLogLevel(level: 'error' | 'warn' | 'info' | 'debug'): void;
+    setLogLevel(level: LogLevel): void;
     /**
      * Initializes the DAppConnector instance.
      * @param logger - `BaseLogger` for logging purposes (optional).
@@ -79,9 +81,10 @@ export declare class DAppConnector {
      */
     connectExtension(extensionId: string, pairingTopic?: string): Promise<SessionTypes.Struct>;
     /**
-     * Validates the session by checking if the session exists.
+     * Validates the session by checking if the session exists and is valid.
+     * Also ensures the signer exists for the session.
      * @param topic - The topic of the session to validate.
-     * @returns {boolean} - True if the session exists, false otherwise.
+     * @returns {boolean} - True if the session exists and has a valid signer, false otherwise.
      */
     private validateSession;
     /**

package/dist/lib/dapp/index.js

@@ -26,6 +26,7 @@ import { DefaultLogger } from '../shared/logger';
 import { HederaJsonRpcMethod, accountAndLedgerFromSession, networkNamespaces, extensionConnect, findExtensions, } from '../shared';
 import { DAppSigner } from './DAppSigner';
 export * from './DAppSigner';
+export { SessionNotFoundError } from './SessionNotFoundError';
 export class DAppConnector {
     /**
      * Initializes the DAppConnector instance.
@@ -113,6 +114,8 @@ export class DAppConnector {
             this.walletConnectClient.on('session_event', this.handleSessionEvent.bind(this));
             this.walletConnectClient.on('session_update', this.handleSessionUpdate.bind(this));
             this.walletConnectClient.on('session_delete', this.handleSessionDelete.bind(this));
+            // Listen for custom session_delete events from DAppSigner
+            this.walletConnectClient.core.events.on('session_delete', this.handleSessionDelete.bind(this));
             this.walletConnectClient.core.pairing.events.on('pairing_delete', this.handlePairingDelete.bind(this));
         }
         catch (e) {
@@ -217,9 +220,10 @@ export class DAppConnector {
         }, pairingTopic, extension.availableInIframe ? undefined : extensionId);
     }
     /**
-     * Validates the session by checking if the session exists.
+     * Validates the session by checking if the session exists and is valid.
+     * Also ensures the signer exists for the session.
      * @param topic - The topic of the session to validate.
-     * @returns {boolean} - True if the session exists, false otherwise.
+     * @returns {boolean} - True if the session exists and has a valid signer, false otherwise.
      */
     validateSession(topic) {
         try {
@@ -227,12 +231,23 @@ export class DAppConnector {
                 return false;
             }
             const session = this.walletConnectClient.session.get(topic);
+            const hasSigner = this.signers.some((signer) => signer.topic === topic);
             if (!session) {
+                // If session doesn't exist but we have a signer for it, clean up
+                if (hasSigner) {
+                    this.logger.warn(`Signer exists but no session found for topic: ${topic}`);
+                    this.handleSessionDelete({ topic });
+                }
+                return false;
+            }
+            if (!hasSigner) {
+                this.logger.warn(`Session exists but no signer found for topic: ${topic}`);
                 return false;
             }
             return true;
         }
-        catch (_a) {
+        catch (e) {
+            this.logger.error('Error validating session:', e);
             return false;
         }
     }
@@ -521,14 +536,24 @@ export class DAppConnector {
     }
     handleSessionDelete(event) {
         this.logger.info('Session deleted:', event);
-        this.signers = this.signers.filter((signer) => signer.topic !== event.topic);
-        try {
-            this.disconnect(event.topic);
-        }
-        catch (e) {
-            this.logger.error('Error disconnecting session:', e);
+        let deletedSigner = false;
+        this.signers = this.signers.filter((signer) => {
+            if (signer.topic !== event.topic) {
+                return true;
+            }
+            deletedSigner = true;
+            return false;
+        });
+        // prevent emitting disconnected event if signers is untouched.
+        if (deletedSigner) {
+            try {
+                this.disconnect(event.topic);
+            }
+            catch (e) {
+                this.logger.error('Error disconnecting session:', e);
+            }
+            this.logger.info('Session deleted and signer removed');
         }
-        this.logger.info('Session deleted by wallet');
     }
     handlePairingDelete(event) {
         this.logger.info('Pairing deleted:', event);

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

@@ -4,11 +4,12 @@ export interface ILogger {
     info(message: string, ...args: any[]): void;
     debug(message: string, ...args: any[]): void;
 }
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'off';
 export declare class DefaultLogger implements ILogger {
     private logLevel;
-    constructor(logLevel?: 'error' | 'warn' | 'info' | 'debug');
-    setLogLevel(level: 'error' | 'warn' | 'info' | 'debug'): void;
-    getLogLevel(): 'error' | 'warn' | 'info' | 'debug';
+    constructor(logLevel?: LogLevel);
+    setLogLevel(level: LogLevel): void;
+    getLogLevel(): LogLevel;
     error(message: string, ...args: any[]): void;
     warn(message: string, ...args: any[]): void;
     info(message: string, ...args: any[]): void;

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

@@ -49,8 +49,8 @@ export declare function base64StringToTransaction<T extends Transaction>(transac
  * @param transaction - a base64 encoded string of proto.TransactionBody.encode().finish()
  * @returns `string`
  * */
-export declare function transactionToTransactionBody<T extends Transaction>(transaction: T, nodeAccountId: AccountId): Uint8Array | null | undefined;
-export declare function transactionBodyToBase64String(transactionBody: Uint8Array): string;
+export declare function transactionToTransactionBody<T extends Transaction>(transaction: T, nodeAccountId: AccountId): any;
+export declare function transactionBodyToBase64String(transactionBody: proto.ITransactionBody): string;
 /**
  * @param transactionList - a proto.TransactionList object
  * @returns `string`
@@ -85,6 +85,12 @@ export declare function base64StringToSignatureMap(base64string: string): proto.
  * @returns Base64-encoded string representation of the input `Uint8Array`
  */
 export declare function Uint8ArrayToBase64String(binary: Uint8Array): string;
+/**
+ * Encodes the binary data represented by the `Uint8Array` to a UTF-8 string.
+ * @param binary - The `Uint8Array` containing binary data to be converted
+ * @returns UTF-8 string representation of the input `Uint8Array`
+ */
+export declare function Uint8ArrayToString(binary: Uint8Array): string;
 /**
  * Converts a Base64-encoded string to a `Uint8Array`.
  * @param base64string - Base64-encoded string to be converted

package/dist/lib/shared/utils.js

@@ -86,10 +86,10 @@ export function base64StringToTransaction(transactionBytes) {
 export function transactionToTransactionBody(transaction, nodeAccountId) {
     // This is a private function, though provides the capabilities to construct a proto.TransactionBody
     //@ts-ignore
-    return transaction._signedTransactions.current.bodyBytes;
+    return transaction._makeTransactionBody(nodeAccountId);
 }
 export function transactionBodyToBase64String(transactionBody) {
-    return Uint8ArrayToBase64String(transactionBody);
+    return Uint8ArrayToBase64String(proto.TransactionBody.encode(transactionBody).finish());
 }
 /**
  * @param transactionList - a proto.TransactionList object
@@ -139,6 +139,14 @@ export function base64StringToSignatureMap(base64string) {
 export function Uint8ArrayToBase64String(binary) {
     return Buffer.from(binary).toString('base64');
 }
+/**
+ * Encodes the binary data represented by the `Uint8Array` to a UTF-8 string.
+ * @param binary - The `Uint8Array` containing binary data to be converted
+ * @returns UTF-8 string representation of the input `Uint8Array`
+ */
+export function Uint8ArrayToString(binary) {
+    return Buffer.from(binary).toString('utf-8');
+}
 /**
  * Converts a Base64-encoded string to a `Uint8Array`.
  * @param base64string - Base64-encoded string to be converted

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hashgraph/hedera-wallet-connect",
-  "version": "1.3.8-canary.e8b789d.0",
+  "version": "1.3.8-canary.ea19d34.0",
   "description": "A library to facilitate integrating Hedera with WalletConnect",
   "repository": {
     "type": "git",
@@ -28,7 +28,7 @@
     "concurrently": "^9.0.1",
     "esbuild": "^0.24.0",
     "esbuild-plugin-copy": "^2.1.1",
-    "eslint-plugin-tsdoc": "^0.3.0",
+    "eslint-plugin-tsdoc": "^0.4.0",
     "husky": "^9.0.6",
     "jest": "^29.7.0",
     "lint-staged": "^15.1.0",
@@ -55,6 +55,7 @@
     "dev:ts-demo": "rimraf dist && npm run build && concurrently --raw \"npm run watch\" \"node scripts/demos/typescript/dev.mjs\"",
     "dev:react-demo": "rimraf dist && npm run build && concurrently --raw \"npm run watch\" \"node scripts/demos/react/dev.mjs\"",
     "test": "jest",
+    "test:watch": "jest --watch",
     "test:connect": "jest --testMatch '**/DAppConnector.test.ts' --verbose",
     "test:signer": "jest --testMatch '**/DAppSigner.test.ts' --verbose",
     "prepublishOnly": "rm -Rf dist && npm run build",