@hashgraph/hedera-wallet-connect 1.3.6-canary.67ec2cf.0 → 1.3.7-canary.14806a9.0

package/dist/{src/lib/dapp → dapp}/DAppSigner.d.ts

@@ -1,12 +1,18 @@
 import { Signer, AccountBalance, AccountId, AccountInfo, Executable, Key, LedgerId, SignerSignature, Transaction, TransactionRecord } from '@hashgraph/sdk';
-import type { ISignClient } from '@walletconnect/types';
+import type { CoreTypes, ISignClient } from '@walletconnect/types';
 export declare class DAppSigner implements Signer {
     private readonly accountId;
     private readonly signClient;
     readonly topic: string;
     private readonly ledgerId;
     readonly extensionId?: string | undefined;
-    constructor(accountId: AccountId, signClient: ISignClient, topic: string, ledgerId?: LedgerId, extensionId?: string | undefined);
+    private logger;
+    constructor(accountId: AccountId, signClient: ISignClient, topic: string, ledgerId?: LedgerId, extensionId?: string | undefined, logLevel?: 'error' | 'warn' | 'info' | 'debug');
+    /**
+     * Sets the logging level for the DAppSigner
+     * @param level - The logging level to set
+     */
+    setLogLevel(level: 'error' | 'warn' | 'info' | 'debug'): void;
     private _getHederaClient;
     private get _signerAccountId();
     private _getRandomNodes;
@@ -24,6 +30,7 @@ export declare class DAppSigner implements Signer {
     getAccountBalance(): Promise<AccountBalance>;
     getAccountInfo(): Promise<AccountInfo>;
     getAccountRecords(): Promise<TransactionRecord[]>;
+    getMetadata(): CoreTypes.Metadata;
     sign(data: Uint8Array[], signOptions?: Record<string, any>): Promise<SignerSignature[]>;
     checkTransaction<T extends Transaction>(transaction: T): Promise<T>;
     populateTransaction<T extends Transaction>(transaction: T): Promise<T>;
@@ -38,6 +45,14 @@ export declare class DAppSigner implements Signer {
     signTransaction<T extends Transaction>(transaction: T): Promise<T>;
     private _tryExecuteTransactionRequest;
     private _parseQueryResponse;
+    /**
+     * Executes a free receipt query without signing a transaction.
+     * Enables the DApp to fetch the receipt of a transaction without making a new request
+     * to the wallet.
+     * @param request - The query to execute
+     * @returns The result of the query
+     */
+    private executeReceiptQueryFromRequest;
     private _tryExecuteQueryRequest;
     call<RequestT, ResponseT, OutputT>(request: Executable<RequestT, ResponseT, OutputT>): Promise<OutputT>;
 }

package/dist/{src/lib/dapp → dapp}/DAppSigner.js

@@ -20,14 +20,25 @@
 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 { DefaultLogger } from '../shared/logger';
 const clients = {};
 export class DAppSigner {
-    constructor(accountId, signClient, topic, ledgerId = LedgerId.MAINNET, extensionId) {
+    constructor(accountId, signClient, topic, ledgerId = LedgerId.MAINNET, extensionId, logLevel = 'debug') {
         this.accountId = accountId;
         this.signClient = signClient;
         this.topic = topic;
         this.ledgerId = ledgerId;
         this.extensionId = extensionId;
+        this.logger = new DefaultLogger(logLevel);
+    }
+    /**
+     * Sets the logging level for the DAppSigner
+     * @param level - The logging level to set
+     */
+    setLogLevel(level) {
+        if (this.logger instanceof DefaultLogger) {
+            this.logger.setLogLevel(level);
+        }
     }
     _getHederaClient() {
         const ledgerIdString = this.ledgerId.toString();
@@ -81,22 +92,33 @@ export class DAppSigner {
     getAccountRecords() {
         return this.call(new AccountRecordsQuery().setAccountId(this.accountId));
     }
+    getMetadata() {
+        return this.signClient.metadata;
+    }
     async sign(data, signOptions) {
-        const { signatureMap } = await this.request({
-            method: HederaJsonRpcMethod.SignMessage,
-            params: {
-                signerAccountId: this._signerAccountId,
-                message: Uint8ArrayToBase64String(data[0]),
-            },
-        });
-        const sigmap = base64StringToSignatureMap(signatureMap);
-        const signerSignature = new SignerSignature({
-            accountId: this.getAccountId(),
-            publicKey: PublicKey.fromBytes(sigmap.sigPair[0].pubKeyPrefix),
-            signature: sigmap.sigPair[0].ed25519 ||
-                sigmap.sigPair[0].ECDSASecp256k1,
-        });
-        return [signerSignature];
+        this.logger.debug('Signing data');
+        try {
+            const { signatureMap } = await this.request({
+                method: HederaJsonRpcMethod.SignMessage,
+                params: {
+                    signerAccountId: this._signerAccountId,
+                    message: Uint8ArrayToBase64String(data[0]),
+                },
+            });
+            const sigmap = base64StringToSignatureMap(signatureMap);
+            const signerSignature = new SignerSignature({
+                accountId: this.getAccountId(),
+                publicKey: PublicKey.fromBytes(sigmap.sigPair[0].pubKeyPrefix),
+                signature: sigmap.sigPair[0].ed25519 ||
+                    sigmap.sigPair[0].ECDSASecp256k1,
+            });
+            this.logger.debug('Data signed successfully');
+            return [signerSignature];
+        }
+        catch (error) {
+            this.logger.error('Error signing data:', error);
+            throw error;
+        }
     }
     async checkTransaction(transaction) {
         throw new Error('Method not implemented.');
@@ -138,7 +160,10 @@ export class DAppSigner {
     }
     async _tryExecuteTransactionRequest(request) {
         try {
-            const transaction = Transaction.fromBytes(request.toBytes());
+            const requestToBytes = request.toBytes();
+            this.logger.debug('Creating transaction from bytes', requestToBytes, request);
+            const transaction = Transaction.fromBytes(requestToBytes);
+            this.logger.debug('Executing transaction request', transaction);
             const result = await this.request({
                 method: HederaJsonRpcMethod.SignAndExecuteTransaction,
                 params: {
@@ -146,9 +171,11 @@ export class DAppSigner {
                     transactionList: transactionToBase64String(transaction),
                 },
             });
+            this.logger.debug('Transaction request completed successfully');
             return { result: TransactionResponse.fromJSON(result) };
         }
         catch (error) {
+            this.logger.error('Error executing transaction request:', error);
             return { error };
         }
     }
@@ -175,9 +202,46 @@ export class DAppSigner {
             throw new Error('Unsupported query type');
         }
     }
+    /**
+     * Executes a free receipt query without signing a transaction.
+     * Enables the DApp to fetch the receipt of a transaction without making a new request
+     * to the wallet.
+     * @param request - The query to execute
+     * @returns The result of the query
+     */
+    async executeReceiptQueryFromRequest(request) {
+        try {
+            const isMainnet = this.ledgerId === LedgerId.MAINNET;
+            const client = isMainnet ? Client.forMainnet() : Client.forTestnet();
+            const receipt = TransactionReceiptQuery.fromBytes(request.toBytes());
+            const result = await receipt.execute(client);
+            return { result };
+        }
+        catch (error) {
+            return { error };
+        }
+    }
     async _tryExecuteQueryRequest(request) {
         try {
-            const query = Query.fromBytes(request.toBytes());
+            const isReceiptQuery = request instanceof TransactionReceiptQuery;
+            if (isReceiptQuery) {
+                this.logger.debug('Attempting to execute free receipt query', request);
+                const result = await this.executeReceiptQueryFromRequest(request);
+                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);
+                }
+            }
+            /**
+             * Note, should we be converting these to specific query types?
+             * Left alone to avoid changing the API for other requests.
+             */
+            const query = isReceiptQuery
+                ? TransactionReceiptQuery.fromBytes(request.toBytes())
+                : Query.fromBytes(request.toBytes());
+            this.logger.debug('Executing query request', query, queryToBase64String(query), isReceiptQuery);
             const result = await this.request({
                 method: HederaJsonRpcMethod.SignAndExecuteQuery,
                 params: {
@@ -185,6 +249,7 @@ export class DAppSigner {
                     query: queryToBase64String(query),
                 },
             });
+            this.logger.debug('Query request completed successfully', result);
             return { result: this._parseQueryResponse(query, result.response) };
         }
         catch (error) {
@@ -192,27 +257,42 @@ export class DAppSigner {
         }
     }
     async call(request) {
-        var _a, _b, _c, _d, _e, _f;
-        const txResult = await this._tryExecuteTransactionRequest(request);
-        if (txResult.result) {
-            return txResult.result;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const isReceiptQuery = request instanceof TransactionReceiptQuery;
+        let txResult = undefined;
+        // a receipt query is a free query and we should not execute a transaction.
+        if (!isReceiptQuery) {
+            txResult = await this._tryExecuteTransactionRequest(request);
+            if (txResult.result) {
+                return txResult.result;
+            }
         }
         const queryResult = await this._tryExecuteQueryRequest(request);
         if (queryResult.result) {
             return queryResult.result;
         }
         // TODO: make this error more usable
+        if (isReceiptQuery) {
+            throw new Error('Error executing receipt query: \n' +
+                JSON.stringify({
+                    queryError: {
+                        name: (_a = queryResult.error) === null || _a === void 0 ? void 0 : _a.name,
+                        message: (_b = queryResult.error) === null || _b === void 0 ? void 0 : _b.message,
+                        stack: (_c = queryResult.error) === null || _c === void 0 ? void 0 : _c.stack,
+                    },
+                }));
+        }
         throw new Error('Error executing transaction or query: \n' +
             JSON.stringify({
                 txError: {
-                    name: (_a = txResult.error) === null || _a === void 0 ? void 0 : _a.name,
-                    message: (_b = txResult.error) === null || _b === void 0 ? void 0 : _b.message,
-                    stack: (_c = txResult.error) === null || _c === void 0 ? void 0 : _c.stack,
+                    name: (_d = txResult === null || txResult === void 0 ? void 0 : txResult.error) === null || _d === void 0 ? void 0 : _d.name,
+                    message: (_e = txResult === null || txResult === void 0 ? void 0 : txResult.error) === null || _e === void 0 ? void 0 : _e.message,
+                    stack: (_f = txResult === null || txResult === void 0 ? void 0 : txResult.error) === null || _f === void 0 ? void 0 : _f.stack,
                 },
                 queryError: {
-                    name: (_d = queryResult.error) === null || _d === void 0 ? void 0 : _d.name,
-                    message: (_e = queryResult.error) === null || _e === void 0 ? void 0 : _e.message,
-                    stack: (_f = queryResult.error) === null || _f === void 0 ? void 0 : _f.stack,
+                    name: (_g = queryResult.error) === null || _g === void 0 ? void 0 : _g.name,
+                    message: (_h = queryResult.error) === null || _h === void 0 ? void 0 : _h.message,
+                    stack: (_j = queryResult.error) === null || _j === void 0 ? void 0 : _j.stack,
                 },
             }, null, 2));
     }

package/dist/{src/lib/dapp → dapp}/index.d.ts

@@ -7,6 +7,7 @@ import { DAppSigner } from './DAppSigner';
 export * from './DAppSigner';
 type BaseLogger = 'error' | 'warn' | 'info' | 'debug' | 'trace' | 'fatal';
 export declare class DAppConnector {
+    private logger;
     dAppMetadata: SignClientTypes.Metadata;
     network: LedgerId;
     projectId: string;
@@ -27,8 +28,14 @@ export declare class DAppConnector {
      * @param methods - Array of supported methods for the DApp (optional).
      * @param events - Array of supported events for the DApp (optional).
      * @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[]);
+    constructor(metadata: SignClientTypes.Metadata, network: LedgerId, projectId: string, methods?: string[], events?: string[], chains?: string[], logLevel?: 'error' | 'warn' | 'info' | 'debug');
+    /**
+     * Sets the logging level for the DAppConnector
+     * @param level - The logging level to set
+     */
+    setLogLevel(level: 'error' | 'warn' | 'info' | 'debug'): void;
     /**
      * Initializes the DAppConnector instance.
      * @param logger - `BaseLogger` for logging purposes (optional).
@@ -71,6 +78,16 @@ export declare class DAppConnector {
      * @returns A Promise that resolves when the connection process is complete.
      */
     connectExtension(extensionId: string, pairingTopic?: string): Promise<SessionTypes.Struct>;
+    /**
+     * Validates the session by checking if the session exists.
+     * @param topic - The topic of the session to validate.
+     * @returns {boolean} - True if the session exists, false otherwise.
+     */
+    private validateSession;
+    /**
+     * Validates the session and refreshes the signers by removing the invalid ones.
+     */
+    private validateAndRefreshSigners;
     /**
      *  Initiates the WallecConnect connection if the wallet in iframe mode is detected.
      */
@@ -81,7 +98,7 @@ export declare class DAppConnector {
      * @param topic - The topic of the session to disconnect.
      * @returns A Promise that resolves when the session is disconnected.
      */
-    disconnect(topic: string): Promise<void>;
+    disconnect(topic: string): Promise<boolean>;
     /**
      * Disconnects all active sessions and pairings.
      *
@@ -127,7 +144,7 @@ export declare class DAppConnector {
      * @example
      * ```ts
      * const params = {
-     *  signerAccountId: '0.0.12345',
+     *  signerAccountId: 'hedera:testnet:0.0.12345',
      *  message: 'Hello World!'
      * }
      *
@@ -194,5 +211,9 @@ export declare class DAppConnector {
      * ```
      */
     signTransaction(params: SignTransactionParams): Promise<SignTransactionResult>;
+    private handleSessionEvent;
+    private handleSessionUpdate;
+    private handleSessionDelete;
+    private handlePairingDelete;
 }
 export default DAppConnector;

package/dist/{src/lib/dapp → dapp}/index.js

@@ -22,6 +22,7 @@ import QRCodeModal from '@walletconnect/qrcode-modal';
 import { WalletConnectModal } from '@walletconnect/modal';
 import SignClient from '@walletconnect/sign-client';
 import { getSdkError } from '@walletconnect/utils';
+import { DefaultLogger } from '../shared/logger';
 import { HederaJsonRpcMethod, accountAndLedgerFromSession, networkNamespaces, extensionConnect, findExtensions, } from '../shared';
 import { DAppSigner } from './DAppSigner';
 export * from './DAppSigner';
@@ -34,8 +35,9 @@ export class DAppConnector {
      * @param methods - Array of supported methods for the DApp (optional).
      * @param events - Array of supported events for the DApp (optional).
      * @param chains - Array of supported chains for the DApp (optional).
+     * @param logLevel - Logging level for the DAppConnector (optional).
      */
-    constructor(metadata, network, projectId, methods, events, chains) {
+    constructor(metadata, network, projectId, methods, events, chains, logLevel = 'debug') {
         this.network = LedgerId.TESTNET;
         this.supportedMethods = [];
         this.supportedEvents = [];
@@ -62,6 +64,7 @@ export class DAppConnector {
                 }
             });
         };
+        this.logger = new DefaultLogger(logLevel);
         this.dAppMetadata = metadata;
         this.network = network;
         this.projectId = projectId;
@@ -77,6 +80,15 @@ export class DAppConnector {
             this.extensions.push(Object.assign(Object.assign({}, metadata), { available: true, availableInIframe: isIframe }));
         });
     }
+    /**
+     * Sets the logging level for the DAppConnector
+     * @param level - The logging level to set
+     */
+    setLogLevel(level) {
+        if (this.logger instanceof DefaultLogger) {
+            this.logger.setLogLevel(level);
+        }
+    }
     /**
      * Initializes the DAppConnector instance.
      * @param logger - `BaseLogger` for logging purposes (optional).
@@ -98,43 +110,13 @@ export class DAppConnector {
                 this.signers = existingSessions.flatMap((session) => this.createSigners(session));
             else
                 this.checkIframeConnect();
-            this.walletConnectClient.on('session_event', (event) => {
-                // Handle session events, such as "chainChanged", "accountsChanged", etc.
-                console.log(event);
-            });
-            this.walletConnectClient.on('session_update', ({ topic, params }) => {
-                // Handle session update
-                const { namespaces } = params;
-                const _session = this.walletConnectClient.session.get(topic);
-                // Overwrite the `namespaces` of the existing session with the incoming one.
-                const updatedSession = Object.assign(Object.assign({}, _session), { namespaces });
-                // Integrate the updated session state into your dapp state.
-                console.log(updatedSession);
-            });
-            this.walletConnectClient.on('session_delete', (pairing) => {
-                console.log(pairing);
-                this.signers = this.signers.filter((signer) => signer.topic !== pairing.topic);
-                // Session was deleted -> reset the dapp state, clean up from user session, etc.
-                try {
-                    this.disconnect(pairing.topic);
-                }
-                catch (e) {
-                    console.error(e);
-                }
-                console.log('Dapp: Session deleted by wallet!');
-            });
-            this.walletConnectClient.core.pairing.events.on('pairing_delete', (pairing) => {
-                console.log(pairing);
-                this.signers = this.signers.filter((signer) => signer.topic !== pairing.topic);
-                try {
-                    this.disconnect(pairing.topic);
-                }
-                catch (e) {
-                    console.error(e);
-                }
-                console.log(`Dapp: Pairing deleted by wallet!`);
-                // clean up after the pairing for `topic` was deleted.
-            });
+            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));
+            this.walletConnectClient.core.pairing.events.on('pairing_delete', this.handlePairingDelete.bind(this));
+        }
+        catch (e) {
+            this.logger.error('Error initializing DAppConnector:', e);
         }
         finally {
             this.isInitializing = false;
@@ -148,6 +130,9 @@ export class DAppConnector {
      * @throws {Error} - If no signer is found for the provided account ID.
      */
     getSigner(accountId) {
+        if (this.isInitializing) {
+            throw new Error('DAppConnector is not initialized yet. Try again later.');
+        }
         const signer = this.signers.find((signer) => signer.getAccountId().equals(accountId));
         if (!signer)
             throw new Error('Signer is not found for this accountId');
@@ -231,6 +216,32 @@ export class DAppConnector {
             extensionConnect(extension.id, extension.availableInIframe, uri);
         }, pairingTopic, extension.availableInIframe ? undefined : extensionId);
     }
+    /**
+     * Validates the session by checking if the session exists.
+     * @param topic - The topic of the session to validate.
+     * @returns {boolean} - True if the session exists, false otherwise.
+     */
+    validateSession(topic) {
+        try {
+            if (!this.walletConnectClient) {
+                return false;
+            }
+            const session = this.walletConnectClient.session.get(topic);
+            if (!session) {
+                return false;
+            }
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    /**
+     * Validates the session and refreshes the signers by removing the invalid ones.
+     */
+    validateAndRefreshSigners() {
+        this.signers = this.signers.filter((signer) => this.validateSession(signer.topic));
+    }
     /**
      *  Initiates the WallecConnect connection if the wallet in iframe mode is detected.
      */
@@ -248,10 +259,20 @@ export class DAppConnector {
      * @returns A Promise that resolves when the session is disconnected.
      */
     async disconnect(topic) {
-        await this.walletConnectClient.disconnect({
-            topic: topic,
-            reason: getSdkError('USER_DISCONNECTED'),
-        });
+        try {
+            if (!this.walletConnectClient) {
+                throw new Error('WalletConnect is not initialized');
+            }
+            await this.walletConnectClient.disconnect({
+                topic: topic,
+                reason: getSdkError('USER_DISCONNECTED'),
+            });
+            return true;
+        }
+        catch (e) {
+            this.logger.error('Either the session was already disconnected or the topic is invalid', e);
+            return false;
+        }
     }
     /**
      * Disconnects all active sessions and pairings.
@@ -271,7 +292,7 @@ export class DAppConnector {
         const disconnectionPromises = [];
         // disconnect sessions
         for (const session of this.walletConnectClient.session.getAll()) {
-            console.log(`Disconnecting from session: ${session}`);
+            this.logger.info(`Disconnecting from session: ${session}`);
             const promise = this.disconnect(session.topic);
             disconnectionPromises.push(promise);
         }
@@ -288,11 +309,38 @@ export class DAppConnector {
         const allNamespaceAccounts = accountAndLedgerFromSession(session);
         return allNamespaceAccounts.map(({ account, network }) => {
             var _a;
-            return new DAppSigner(account, this.walletConnectClient, session.topic, network, (_a = session.sessionProperties) === null || _a === void 0 ? void 0 : _a.extensionId);
+            return new DAppSigner(account, this.walletConnectClient, session.topic, network, (_a = session.sessionProperties) === null || _a === void 0 ? void 0 : _a.extensionId, this.logger instanceof DefaultLogger ? this.logger.getLogLevel() : 'debug');
         });
     }
     async onSessionConnected(session) {
-        this.signers.push(...this.createSigners(session));
+        const newSigners = this.createSigners(session);
+        // Filter out any existing signers with duplicate AccountIds
+        for (const newSigner of newSigners) {
+            // We check if any signers have the same account, extension + metadata name.
+            const existingSigners = this.signers.filter((currentSigner) => {
+                var _a, _b;
+                const matchingAccountId = ((_a = currentSigner === null || currentSigner === void 0 ? void 0 : currentSigner.getAccountId()) === null || _a === void 0 ? void 0 : _a.toString()) === ((_b = newSigner === null || newSigner === void 0 ? void 0 : newSigner.getAccountId()) === null || _b === void 0 ? void 0 : _b.toString());
+                const matchingExtensionId = newSigner.extensionId === currentSigner.extensionId;
+                const newSignerMetadata = newSigner.getMetadata();
+                const existingSignerMetadata = currentSigner.getMetadata();
+                const metadataNameMatch = (newSignerMetadata === null || newSignerMetadata === void 0 ? void 0 : newSignerMetadata.name) === (existingSignerMetadata === null || existingSignerMetadata === void 0 ? void 0 : existingSignerMetadata.name);
+                if (currentSigner.topic === newSigner.topic) {
+                    this.logger.error('The topic was already connected. This is a weird error. Please report it.', newSigner.getAccountId().toString());
+                }
+                return matchingAccountId && matchingExtensionId && metadataNameMatch;
+            });
+            // Any dupes get disconnected + removed from the signers array.
+            for (const existingSigner of existingSigners) {
+                this.logger.debug(`Disconnecting duplicate signer for account ${existingSigner.getAccountId().toString()}`);
+                await this.disconnect(existingSigner.topic);
+                this.signers = this.signers.filter((s) => s.topic !== existingSigner.topic);
+            }
+        }
+        // Add new signers after all duplicates have been cleaned up
+        this.signers.push(...newSigners);
+        this.logger.debug(`Current signers after connection: ${this.signers
+            .map((s) => `${s.getAccountId().toString()}:${s.topic}`)
+            .join(', ')}`);
     }
     async connectURI(pairingTopic) {
         if (!this.walletConnectClient) {
@@ -304,10 +352,25 @@ export class DAppConnector {
         });
     }
     async request({ method, params, }) {
-        const signer = this.signers[this.signers.length - 1];
+        var _a, _b, _c;
+        let signer;
+        this.logger.debug(`Requesting method: ${method} with params: ${JSON.stringify(params)}`);
+        if (params === null || params === void 0 ? void 0 : params.signerAccountId) {
+            // Extract the actual account ID from the hedera:<network>:<address> format
+            const actualAccountId = (_b = (_a = params === null || params === void 0 ? void 0 : params.signerAccountId) === null || _a === void 0 ? void 0 : _a.split(':')) === null || _b === void 0 ? void 0 : _b.pop();
+            signer = this.signers.find((s) => { var _a; return ((_a = s === null || s === void 0 ? void 0 : s.getAccountId()) === null || _a === void 0 ? void 0 : _a.toString()) === actualAccountId; });
+            this.logger.debug(`Found signer: ${(_c = signer === null || signer === void 0 ? void 0 : signer.getAccountId()) === null || _c === void 0 ? void 0 : _c.toString()}`);
+            if (!signer) {
+                throw new Error(`Signer not found for account ID: ${params === null || params === void 0 ? void 0 : params.signerAccountId}. Did you use the correct format? e.g hedera:<network>:<address> `);
+            }
+        }
+        else {
+            signer = this.signers[this.signers.length - 1];
+        }
         if (!signer) {
             throw new Error('There is no active session. Connect to the wallet at first.');
         }
+        this.logger.debug(`Using signer: ${signer.getAccountId().toString()}: ${signer.topic} - about to request.`);
         return await signer.request({
             method: method,
             params: params,
@@ -357,7 +420,7 @@ export class DAppConnector {
      * @example
      * ```ts
      * const params = {
-     *  signerAccountId: '0.0.12345',
+     *  signerAccountId: 'hedera:testnet:0.0.12345',
      *  message: 'Hello World!'
      * }
      *
@@ -444,5 +507,39 @@ export class DAppConnector {
             params,
         });
     }
+    handleSessionEvent(args) {
+        this.logger.debug('Session event received:', args);
+        this.validateAndRefreshSigners();
+    }
+    handleSessionUpdate({ topic, params, }) {
+        const { namespaces } = params;
+        const _session = this.walletConnectClient.session.get(topic);
+        const updatedSession = Object.assign(Object.assign({}, _session), { namespaces });
+        this.logger.info('Session updated:', updatedSession);
+        this.signers = this.signers.filter((signer) => signer.topic !== topic);
+        this.signers.push(...this.createSigners(updatedSession));
+    }
+    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);
+        }
+        this.logger.info('Session deleted by wallet');
+    }
+    handlePairingDelete(event) {
+        this.logger.info('Pairing deleted:', event);
+        this.signers = this.signers.filter((signer) => signer.topic !== event.topic);
+        try {
+            this.disconnect(event.topic);
+        }
+        catch (e) {
+            this.logger.error('Error disconnecting pairing:', e);
+        }
+        this.logger.info('Pairing deleted by wallet');
+    }
 }
 export default DAppConnector;

package/dist/shared/logger.d.ts

@@ -0,0 +1,16 @@
+export interface ILogger {
+    error(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    debug(message: string, ...args: any[]): void;
+}
+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';
+    error(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    debug(message: string, ...args: any[]): void;
+}

package/dist/shared/logger.js

@@ -0,0 +1,32 @@
+export class DefaultLogger {
+    constructor(logLevel = 'info') {
+        this.logLevel = 'info';
+        this.logLevel = logLevel;
+    }
+    setLogLevel(level) {
+        this.logLevel = level;
+    }
+    getLogLevel() {
+        return this.logLevel;
+    }
+    error(message, ...args) {
+        if (['error', 'warn', 'info', 'debug'].includes(this.logLevel)) {
+            console.error(`[ERROR] ${message}`, ...args);
+        }
+    }
+    warn(message, ...args) {
+        if (['warn', 'info', 'debug'].includes(this.logLevel)) {
+            console.warn(`[WARN] ${message}`, ...args);
+        }
+    }
+    info(message, ...args) {
+        if (['info', 'debug'].includes(this.logLevel)) {
+            console.info(`[INFO] ${message}`, ...args);
+        }
+    }
+    debug(message, ...args) {
+        if (this.logLevel === 'debug') {
+            console.debug(`[DEBUG] ${message}`, ...args);
+        }
+    }
+}

package/dist/{src/lib/shared → 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`