@hashgraph/hedera-wallet-connect 1.3.3 → 1.3.7-canary.519a0db.0

package/README.md

@@ -52,245 +52,19 @@ _The relay and this library have different intentions and serve different purpos
 native Hedera integration vs. Ethereum compatability layers to ease developer onboarding for
 those more familiar with the Ethereum ecosystem._
 
-## Set up
+# Documentation
 
-To start using WalletConnect, sign up for an account at <https://cloud.walletconnect.com>. You
-will use your project id when initializing client libraries.
+WalletConnect <> Hedera docs are fully hosted on [https://hwc-docs.hgraph.app/](https://hwc-docs.hgraph.app/)
 
-It is important to understand core WalletConnect concepts when integrating this library. Please
-reference the [WalletConnect documentation](https://docs.walletconnect.com/2.0/).
+- [Installation](/docs/docs/installation.md)
+- [dApp Guide](/docs/docs/dapp-guide.md)
+- [Wallet Guide](/docs/docs/wallet-guide.md)
+- [Signing Messages](/docs/docs/sign-messages.md)
+- [Demos](/docs/docs/demos.md)
 
-## Usage
+# Accessing the docs locally
 
-Upon successfully configuring your dApp and/or wallet to manage WalletConnect sessions, you can
-use this library’s functions to easily create and handle requests for the Hedera network.
-
-### Installation
-
-`npm i --save @hashgraph/hedera-wallet-connect`
-
-### Example code
-
-- [Typescript dApp example code](demos/typescript/dapp/main.ts)
-- [Typescript Wallet example code](demos/typescript/wallet/main.ts)
-- [React dApp example code](demos/react-dapp)
-
-
-### DApps
-
-#### Signer
-
-This library provides a `DAppSigner` class that implements the `@hashgraph/sdk`'s `Signer`
-interface. You may use the `DAppSigner` class to sign and execute transactions on the Hedera
-network.
-
-##### Get Signer
-
-After you have paired your wallet with your dApp, you can get the signer from the
-`DAppConnector` instance:
-
-```javascript
-const signer = dAppConnector.signers[0] // DAppSigner
-```
-
-Or, if multiple signers are available, you can find the signer by account ID:
-
-```javascript
-const signer = dAppConnector.signers.find(
-  (signer_) => signer_.getAccountId().toString() === '0.0.100',
-) // DAppSigner
-```
-
-##### Sign Transactions
-
-```javascript
-const transaction = new TransferTransaction()
-  .addHbarTransfer('0.0.100', new Hbar(-1))
-  .addHbarTransfer('0.0.101', new Hbar(1))
-
-await transaction.freezeWithSigner(signer)
-const signedTransaction = await signer.signTransaction(transaction)
-```
-
-##### Sign and Execute Transactions
-
-```javascript
-const transaction = new TransferTransaction()
-  .addHbarTransfer('0.0.100', new Hbar(-1))
-  .addHbarTransfer('0.0.101', new Hbar(1))
-
-await transaction.freezeWithSigner(signer)
-const transactionResponse = await transaction.executeWithSigner(signer)
-```
-
-##### Sign and verify messages
-
-```javascript
-const text = 'Example message to sign'
-const base64String = btoa(text)
-
-const sigMaps = await signer.sign([base64StringToUint8Array(base64String)]) // import { base64StringToUint8Array } from '@hashgraph/hedera-wallet-connect'
-
-// sigMaps[0].publicKey also contains the public key of the signer, but you should obtain a PublicKey you can trust from a mirror node.
-const verifiedResult = verifySignerSignature(base64String, sigMaps[0], publicKey) // import { verifySignerSignature } from '@hashgraph/hedera-wallet-connect'
-```
-
-### Wallet
-
-This library provides a Wallet class that extends the
-[ Web3Wallet ](https://github.com/WalletConnect/walletconnect-monorepo/tree/v2.0/packages/web3wallet)
-class provided by WalletConnect class
-
-#### Event Listeners
-
-WalletConnect emits various events during a session. Listen to these events to synchronize the
-state of your application:
-
-```javascript
-// Handle pairing proposals
-signClient.on('session_proposal', (event) => {
-  // Display session proposal to the user and decide to approve or reject
-})
-
-// Handle session requests, like signing transactions or messages
-signClient.on('session_request', (event) => {
-  // Process the session request
-})
-
-// Handle session deletions
-signClient.on('session_delete', (event) => {
-  // React to session termination
-})
-```
-
-#### Pairing with dApps
-
-Pairing establishes a connection between the wallet and a dApp. Once paired, the dApp can send
-session requests to the wallet.
-
-##### a. Pairing via URI
-
-If a dApp shares a URI for pairing:
-
-```javascript
-await signClient.core.pairing.pair({ uri: 'RECEIVED_URI' })
-```
-
-Upon successful pairing, the `session_proposal` event will be triggered.
-
-##### b. Pairing via QR Codes
-
-For a better user experience, dApps often share QR codes that wallets can scan to establish a
-pairing. Use a QR code scanning library to scan and obtain the URI, then proceed with pairing:
-
-```javascript
-const scannedUri = '...' // URI obtained from scanning the QR code
-await signClient.core.pairing.pair({ uri: scannedUri })
-```
-
-#### Handling Session Proposals
-
-Upon receiving a `session_proposal` event, display the proposal details to the user. Allow them
-to approve or reject the session:
-
-##### Handling Session Requests
-
-Upon receiving a `session_request` event, process the request. For instance, if the dApp
-requests a transaction to be signed:
-
-#### Extension popup
-
-By default, it is not possible to directly pop up an extension with Wallet Connect. However, to
-allow this possibility, the dAppConnector look for extensions. If you create the AppConnector,
-it will automatically send a message to the extension to detect if it is installed. In case the
-extension is installed, it will be added to the available extensions and its data can be found
-at the extensions property of dAppConnector.
-
-To connect an available extension, use the method `connectExtension(<extensionId>)`. This will
-link the extension to the signer and session. Whenever you use the signer created for this
-session, the extension will automatically open. You can find out if the extension is available
-by checking the `extensions` property.
-
-```javascript
-const dAppConnector = new DAppConnector(
-  dAppMetadata,
-  LedgerId.TESTNET,
-  projectId,
-  Object.values(HederaJsonRpcMethod),
-  [HederaSessionEvent.ChainChanged, HederaSessionEvent.AccountsChanged],
-  [HederaChainId.Testnet]
-)
-
-[...]
-
-dAppConnector?.extensions?.forEach((extension) => {
-  console.log(extension)
-})
-
-const extension = dAppConnector?.extensions?.find((extension) => extension.name === '<Extension name>')
-if (extension.available) {
-  await dAppConnector!.connectExtension(extension.id);
-  const signer = dAppConnector.getSigner(AccountId.fromString('0.0.12345'))
-
-  // This request will open the extension
-  const response = await signer.signAndExecuteTransaction(transaction)
-}
-```
-
-Wallets that are compatible should be able to receive and respond to the following messages:
-
-- `"hedera-extension-query"`: The extension is required to respond with
-  `"hedera-extension-response"` and provide the next set of data in the metadata property.
-  ```javascript
-  let metadata = {
-    id: '<extesnionId>',
-    name: '<Wallet name>',
-    url: '<Wallet url>',
-    icon: '<Wallet con>',
-    description: '<Wallet url>',
-  }
-  ```
-- `"hedera-extension-open-<extensionId>"`: The extension needs to listen to this message and
-  automatically open.
-- `"hedera-extension-connect-<extensionId>"`: The extension must listen to this message and
-  utilize the `pairingString` property in order to establish a connection.
-
-This communication protocol between the wallet and web dApps requires an intermediate script to
-use the Chrome API. Refer to the
-[Chrome Extensions documentation](https://developer.chrome.com/docs/extensions/develop/concepts/messaging)
-
-To enable communication between the extension and a web dApp embedded in an iframe, the wallet
-must support the following messages:
-
-- `"hedera-iframe-query"`:The extension is required to respond with `"hedera-iframe-response"`
-  and provide the next set of data in the metadata property.
-  ```javascript
-  let metadata = {
-    id: '<Wallet extension id>',
-    name: '<Wallet name>',
-    url: '<Wallet url>',
-    icon: '<Wallet icon>',
-    description: '<Wallet description>',
-  }
-  ```
-- `"hedera-iframe-connect"`: The extension must listen to this message and utilize the
-  `pairingString` property in order to establish a connection.
-
-The dAppConnector is designed to automatically initiate pairing without any need for user
-action, in case no sessions are noticed and an iframe extension is detected. To capture this
-event and the newly established session, you can utilize the `onSessionIframeCreated` function.
-
-## Demo & docs
-
-This repository includes a vanilla html/css/javascript implementation with a dApp and wallet
-example useful for testing and development while integrating WalletConnect and Hedera.
-
-The docs site utilizes [Typedoc](https://typedoc.org) to generate a library documentation site
-at <https://wc.hgraph.app/docs/>
-
-The demo source code lives in `./demos/typescript` and is available at
-<https://wc.hgraph.app>
-
-## Passing tests
-
-- `git commit -Ss "the commit message"`
+- `cd docs`
+- `npm install`
+- `npm run docs`
+- Navigating to `localhost:3000`

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

@@ -1,5 +1,5 @@
 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;
@@ -24,6 +24,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>;

package/dist/src/lib/dapp/DAppSigner.js

@@ -49,8 +49,9 @@ export class DAppSigner {
         return allNodes.slice(0, numberOfNodes);
     }
     request(request) {
-        if (this.extensionId)
+        if (this.extensionId) {
             extensionOpen(this.extensionId);
+        }
         return this.signClient.request({
             topic: this.topic,
             request,
@@ -81,6 +82,9 @@ 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,

package/dist/src/lib/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!'
      * }
      *

package/dist/src/lib/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).
@@ -87,20 +99,24 @@ export class DAppConnector {
             if (!this.projectId) {
                 throw new Error('Project ID is not defined');
             }
-            this.walletConnectClient = await SignClient.init({
+            const signClient = await SignClient.init({
                 logger,
                 relayUrl: 'wss://relay.walletconnect.com',
                 projectId: this.projectId,
                 metadata: this.dAppMetadata,
             });
+            this.walletConnectClient = signClient;
             const existingSessions = this.walletConnectClient.session.getAll();
-            if (existingSessions.length > 0)
+            if (existingSessions.length > 0) {
                 this.signers = existingSessions.flatMap((session) => this.createSigners(session));
-            else
-                this.checkIframeConnect();
+            }
+            else {
+                await this.checkIframeConnect();
+            }
             this.walletConnectClient.on('session_event', (event) => {
                 // Handle session events, such as "chainChanged", "accountsChanged", etc.
-                console.log(event);
+                this.logger.debug('Session event received:', event);
+                this.validateAndRefreshSigners();
             });
             this.walletConnectClient.on('session_update', ({ topic, params }) => {
                 // Handle session update
@@ -109,24 +125,37 @@ export class DAppConnector {
                 // 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.logger.info('Session updated:', updatedSession);
+                this.signers = this.signers.filter((signer) => signer.topic !== topic);
+                this.signers.push(...this.createSigners(updatedSession));
             });
             this.walletConnectClient.on('session_delete', (pairing) => {
-                console.log(pairing);
+                this.logger.info('Session deleted:', pairing);
                 this.signers = this.signers.filter((signer) => signer.topic !== pairing.topic);
-                this.disconnect(pairing.topic);
                 // Session was deleted -> reset the dapp state, clean up from user session, etc.
-                console.log('Dapp: Session deleted by wallet!');
+                try {
+                    this.disconnect(pairing.topic);
+                }
+                catch (e) {
+                    this.logger.error('Error disconnecting session:', e);
+                }
+                this.logger.info('Session deleted by wallet');
             });
             this.walletConnectClient.core.pairing.events.on('pairing_delete', (pairing) => {
-                // Session was deleted
-                console.log(pairing);
+                this.logger.info('Pairing deleted:', pairing);
                 this.signers = this.signers.filter((signer) => signer.topic !== pairing.topic);
-                this.disconnect(pairing.topic);
-                console.log(`Dapp: Pairing deleted by wallet!`);
-                // clean up after the pairing for `topic` was deleted.
+                try {
+                    this.disconnect(pairing.topic);
+                }
+                catch (e) {
+                    this.logger.error('Error disconnecting pairing:', e);
+                }
+                this.logger.info('Pairing deleted by wallet');
             });
         }
+        catch (e) {
+            this.logger.error('Error initializing DAppConnector:', e);
+        }
         finally {
             this.isInitializing = false;
         }
@@ -139,6 +168,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');
@@ -222,6 +254,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.
      */
@@ -239,10 +297,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.
@@ -262,7 +330,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);
         }
@@ -283,7 +351,34 @@ export class DAppConnector {
         });
     }
     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(async (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) {
@@ -295,10 +390,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,
@@ -348,7 +458,7 @@ export class DAppConnector {
      * @example
      * ```ts
      * const params = {
-     *  signerAccountId: '0.0.12345',
+     *  signerAccountId: 'hedera:testnet:0.0.12345',
      *  message: 'Hello World!'
      * }
      *

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

@@ -0,0 +1,15 @@
+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;
+    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/src/lib/shared/logger.js

@@ -0,0 +1,29 @@
+export class DefaultLogger {
+    constructor(logLevel = 'info') {
+        this.logLevel = 'info';
+        this.logLevel = logLevel;
+    }
+    setLogLevel(level) {
+        this.logLevel = level;
+    }
+    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/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`

package/dist/src/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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hashgraph/hedera-wallet-connect",
-  "version": "1.3.3",
+  "version": "1.3.7-canary.519a0db.0",
   "description": "A library to facilitate integrating Hedera with WalletConnect",
   "repository": {
     "type": "git",
@@ -16,7 +16,9 @@
   ],
   "license": "Apache-2.0",
   "devDependencies": {
-    "@hashgraph/hedera-wallet-connect": "^1.3.1",
+    "@hashgraph/hedera-wallet-connect": "^1.3.4",
+    "@swc/core": "^1.7.40",
+    "@swc/jest": "^0.2.36",
     "@types/jest": "^29.5.3",
     "@types/node": "^22.5.0",
     "@types/react-dom": "^18.2.21",
@@ -36,7 +38,6 @@
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "rimraf": "^5.0.5",
-    "ts-jest": "^29.1.2",
     "ts-node": "^10.9.2",
     "typedoc": "^0.26.3",
     "typedoc-theme-hierarchy": "^4.1.2",
@@ -49,6 +50,7 @@
     "build:docs": "typedoc --options typedoc.json",
     "watch": "nodemon --watch src/lib/ --ext ts --exec \"npm run build\"",
     "dev": "npm run dev:ts-demo",
+    "dev:docs": "cd docs && npm run start",
     "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",
@@ -58,6 +60,7 @@
     "prepare": "husky install",
     "prettier:check": "prettier --check ./src/",
     "prettier:fix": "prettier --write ./src/",
+    "prod:docs-docker": "sh docker-run.sh",
     "test:sigMap": "jest --testMatch '**/SignatureMapHelpers.test.ts' --verbose"
   },
   "peerDependencies": {