@hashgraph/hedera-wallet-connect 2.0.4-canary.f71fa76.0 → 2.0.5-canary.7b24ac9.0

package/README.md

@@ -13,7 +13,7 @@ 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
+the [Ethereum JSON-RPC](https://ethereum.org/en/developers/docs/apis/json-rpc/). To achieve
 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
@@ -26,7 +26,7 @@ transactions to wallets over the WalletConnect network using the JSON-RPC spec d
 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.
 
-On a high level, JSON-RPC is a type of API stucture, such as SOAP, gRPC, REST, GraphQL, etc. In
+On a high level, JSON-RPC is a type of API structure, 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
@@ -34,7 +34,7 @@ the Hedera ecosystem, there are distinct concepts regarding JSON-RPC APIs to con
 - 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
+  the WalletConnect network distinct from other JSON-RPC specs such as the one defined by the
   Ethereum network.
 
 For more information see:
@@ -64,7 +64,7 @@ reviewing the [Reown docs](https://docs.reown.com/overview).
 1. Add Hedera dependencies to your project:
 
 ```sh
-npm install @hashgraph/hedera-wallet-connect@2.0.0-canary.811af2f.0 @hashgraph/sdk @walletconnect/modal
+npm install @hashgraph/hedera-wallet-connect @hashgraph/sdk @walletconnect/modal
 ```
 
 2. Initialize dApp Connector
@@ -121,7 +121,7 @@ await dAppConnector.openModal()
 2. Add Hedera dependencies to your project:
 
 ```sh
-npm install @hashgraph/hedera-wallet-connect@2.0.1-canary.24fffa7.0 @hashgraph/sdk @walletconnect/universal-provider
+npm install @hashgraph/hedera-wallet-connect@2.0.4-canary.3ca04e9.0 @hashgraph/sdk @walletconnect/universal-provider
 ```
 
 3. Update `createAppKit` with adapters and a universal provider for Hedera. Note the
@@ -154,7 +154,7 @@ const hederaEVMAdapter = new HederaAdapter({
 })
 
 const universalProvider = (await HederaProvider.init({
-  projectId: "YOUR_PROJECT_ID"
+  projectId: "YOUR_PROJECT_ID",
   metadata,
 })) as unknown as UniversalProvider, // avoid type mismatch error due to missing of private properties in HederaProvider
 
@@ -211,6 +211,141 @@ createAppKit({
 - [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>
 
+# Multi-Signature Transactions
+
+Multi-signature (multi-sig) workflows allow multiple parties to sign a single transaction before it's executed on the Hedera network. This is commonly used for:
+
+- Treasury operations requiring approval from multiple parties
+- Escrow services
+- Joint accounts
+- Backend co-signing for additional security
+
+## Using `hedera_signTransaction` for Multi-Sig Workflows
+
+The `hedera_signTransaction` method allows you to collect a signature from a wallet without immediately executing the transaction. This signature can then be combined with additional signatures (such as from a backend service) before final execution.
+
+### Example: Frontend Wallet Signature + Backend Co-Signature
+
+This example demonstrates a common pattern where a user signs a transaction in their wallet, and then a backend service adds its signature before executing the transaction.
+
+#### Step 1: Create and Sign Transaction on Frontend
+
+```typescript
+import { DAppConnector, HederaJsonRpcMethod } from '@hashgraph/hedera-wallet-connect'
+import { TransferTransaction, Hbar, AccountId } from '@hashgraph/sdk'
+
+// Initialize your DAppConnector (see Getting Started section)
+const dAppConnector = new DAppConnector(/* ... */)
+
+// Create a transaction
+const transaction = new TransferTransaction()
+  .addHbarTransfer(userAccountId, new Hbar(-10))
+  .addHbarTransfer(recipientAccountId, new Hbar(10))
+  .setTransactionMemo('Multi-sig transfer')
+
+// Request signature from wallet (does NOT execute)
+const signer = dAppConnector.getSigner(userAccountId)
+const signedTransaction = await signer.signTransaction(transaction)
+
+// Convert signed transaction to bytes for transmission to backend
+const signedTransactionBytes = signedTransaction.toBytes()
+
+// Send to backend
+const response = await fetch('/api/execute-transaction', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    signedTransaction: Buffer.from(signedTransactionBytes).toString('base64'),
+  }),
+})
+
+const result = await response.json()
+console.log('Transaction executed:', result.transactionId)
+```
+
+#### Step 2: Add Backend Signature and Execute
+
+On your backend, use the `addSignatureToTransaction` utility to add your server's signature:
+
+```typescript
+import { Transaction, PrivateKey, Client } from '@hashgraph/sdk'
+import { addSignatureToTransaction } from '@hashgraph/hedera-wallet-connect'
+
+// Backend API endpoint
+app.post('/api/execute-transaction', async (req, res) => {
+  try {
+    // Reconstruct transaction from bytes
+    const signedTransactionBytes = Buffer.from(req.body.signedTransaction, 'base64')
+    const signedTransaction = Transaction.fromBytes(signedTransactionBytes)
+
+    // Load your backend private key (store securely!)
+    const backendPrivateKey = PrivateKey.fromStringED25519(process.env.BACKEND_PRIVATE_KEY)
+
+    // Add backend signature to the transaction
+    const fullySignedTransaction = await addSignatureToTransaction(
+      signedTransaction,
+      backendPrivateKey,
+    )
+
+    // Execute the fully signed transaction
+    const client = Client.forTestnet() // or Client.forMainnet()
+    client.setOperator(backendAccountId, backendPrivateKey)
+
+    const txResponse = await fullySignedTransaction.execute(client)
+    const receipt = await txResponse.getReceipt(client)
+
+    res.json({
+      success: true,
+      transactionId: txResponse.transactionId.toString(),
+      status: receipt.status.toString(),
+    })
+  } catch (error) {
+    console.error('Error executing transaction:', error)
+    res.status(500).json({ error: error.message })
+  }
+})
+```
+
+### Important Notes
+
+1. **Transaction Must Be Frozen**: Before signing, ensure your transaction is frozen.
+
+2. **Signature Order**: Signatures can be added in any order. Hedera validates that all required signatures are present when the transaction is executed.
+
+3. **Security Considerations**:
+   - Never expose backend private keys to the frontend
+   - Validate transaction contents on the backend before adding your signature
+   - Implement proper authentication and authorization
+   - Consider implementing transaction limits and approval workflows
+
+4. **Multiple Signatures**: You can add more than two signatures using the same pattern:
+
+```typescript
+// Add multiple signatures sequentially
+let signedTx = await addSignatureToTransaction(transaction, privateKey1)
+signedTx = await addSignatureToTransaction(signedTx, privateKey2)
+signedTx = await addSignatureToTransaction(signedTx, privateKey3)
+
+// Execute with all signatures
+await signedTx.execute(client)
+```
+
+5. **Threshold Keys**: For accounts with threshold key structures, ensure you collect enough signatures to meet the threshold requirement before execution.
+
+### Alternative: Using `hedera_signAndExecuteTransaction`
+
+If you don't need backend co-signing and want the wallet to execute the transaction immediately:
+
+```typescript
+// This signs AND executes in one call
+const result = await dAppConnector.signAndExecuteTransaction({
+  signerAccountId: `hedera:testnet:${userAccountId}`,
+  transactionList: transactionToBase64String(transaction),
+})
+```
+
+Use `hedera_signTransaction` when you need to collect multiple signatures. Use `hedera_signAndExecuteTransaction` when the wallet's signature alone is sufficient to execute the transaction.
+
 # Hedera Wallets
 
 - [Hashpack](https://hashpack.app/)
@@ -226,12 +361,10 @@ refer to how to send transactions to wallets using the `hedera:(mainnet|testnet)
 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/DAppSigner.js

@@ -146,7 +146,15 @@ export class DAppSigner {
      * @returns transaction - `Transaction` object with signature
      */
     async signTransaction(transaction) {
-        const transactionBody = transactionToTransactionBody(transaction);
+        var _a, _b;
+        // Ensure transaction is frozen with node account IDs before signing
+        // This is required so the transaction can be executed later by any client
+        if (!transaction.isFrozen()) {
+            transaction.freezeWith(this._getHederaClient());
+        }
+        // Extract the first node account ID from the frozen transaction to preserve it in the transaction body
+        const nodeAccountId = (_b = (_a = transaction.nodeAccountIds) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : null;
+        const transactionBody = transactionToTransactionBody(transaction, nodeAccountId);
         if (!transactionBody)
             throw new Error('Failed to serialize transaction body');
         const transactionBodyBase64 = transactionBodyToBase64String(transactionBody);
@@ -158,9 +166,44 @@ export class DAppSigner {
             },
         });
         const sigMap = base64StringToSignatureMap(signatureMap);
-        const bodyBytes = base64StringToUint8Array(transactionBodyBase64);
-        const bytes = proto.Transaction.encode({ bodyBytes, sigMap }).finish();
-        return Transaction.fromBytes(bytes);
+        // Get the original transaction bytes to preserve the full transaction structure
+        // including all node account IDs
+        const originalTransactionBytes = transaction.toBytes();
+        const originalTransactionList = proto.TransactionList.decode(originalTransactionBytes);
+        // Add the signature to all transactions in the list
+        // Each transaction in the list corresponds to a different node
+        const signedTransactionList = originalTransactionList.transactionList.map((tx) => {
+            // Check if the transaction has signedTransactionBytes (frozen transactions)
+            if (tx.signedTransactionBytes) {
+                // Decode the SignedTransaction to access the bodyBytes and existing sigMap
+                const signedTx = proto.SignedTransaction.decode(tx.signedTransactionBytes);
+                const existingSigMap = signedTx.sigMap || proto.SignatureMap.create({});
+                // Merge the new signatures with existing signatures
+                const mergedSigPairs = [...(existingSigMap.sigPair || []), ...(sigMap.sigPair || [])];
+                // Create updated SignedTransaction with merged signatures
+                const updatedSignedTx = proto.SignedTransaction.encode({
+                    bodyBytes: signedTx.bodyBytes,
+                    sigMap: proto.SignatureMap.create({
+                        sigPair: mergedSigPairs,
+                    }),
+                }).finish();
+                return {
+                    signedTransactionBytes: updatedSignedTx,
+                };
+            }
+            else {
+                // Transaction has bodyBytes and sigMap at the top level (not frozen)
+                const existingSigMap = tx.sigMap || proto.SignatureMap.create({});
+                // Merge the new signatures with existing signatures
+                const mergedSigPairs = [...(existingSigMap.sigPair || []), ...(sigMap.sigPair || [])];
+                return Object.assign(Object.assign({}, tx), { sigMap: Object.assign(Object.assign({}, existingSigMap), { sigPair: mergedSigPairs }) });
+            }
+        });
+        // Encode the signed transaction list back to bytes
+        const signedBytes = proto.TransactionList.encode({
+            transactionList: signedTransactionList,
+        }).finish();
+        return Transaction.fromBytes(signedBytes);
     }
     async _tryExecuteTransactionRequest(request) {
         try {

package/dist/lib/dapp/index.js

@@ -355,9 +355,17 @@ export class DAppConnector {
         if (!this.walletConnectClient) {
             throw new Error('WalletConnect is not initialized');
         }
+        const requiredNamespaces = networkNamespaces(this.network, this.supportedMethods, this.supportedEvents);
+        this.logger.debug('V1 DAppConnector: Connecting with params:', {
+            network: this.network.toString(),
+            pairingTopic,
+            requiredNamespaces,
+            supportedMethods: this.supportedMethods,
+            supportedEvents: this.supportedEvents,
+        });
         return this.walletConnectClient.connect({
             pairingTopic,
-            requiredNamespaces: networkNamespaces(this.network, this.supportedMethods, this.supportedEvents),
+            requiredNamespaces,
         });
     }
     async request({ method, params, }) {

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

@@ -16,3 +16,6 @@ export declare class DefaultLogger implements ILogger {
     info(message: string, ...args: any[]): void;
     debug(message: string, ...args: any[]): void;
 }
+export declare function setGlobalLogLevel(level: LogLevel): void;
+export declare function getGlobalLogLevel(): LogLevel;
+export declare function createLogger(name: string, level?: LogLevel): DefaultLogger;

package/dist/lib/shared/logger.js

@@ -1,3 +1,4 @@
+var _a;
 export class DefaultLogger {
     constructor(logLevel = 'info', name) {
         this.logLevel = 'info';
@@ -31,3 +32,32 @@ export class DefaultLogger {
         }
     }
 }
+// Global logger configuration
+let globalLogLevel = 'info';
+// Check if environment variable is set
+if (typeof process !== 'undefined' && ((_a = process.env) === null || _a === void 0 ? void 0 : _a.HWC_LOG_LEVEL)) {
+    const envLevel = process.env.HWC_LOG_LEVEL.toLowerCase();
+    if (['error', 'warn', 'info', 'debug', 'off'].includes(envLevel)) {
+        globalLogLevel = envLevel;
+    }
+}
+// Check if localStorage is available (browser environment)
+if (typeof localStorage !== 'undefined') {
+    const storedLevel = localStorage.getItem('hwc_log_level');
+    if (storedLevel && ['error', 'warn', 'info', 'debug', 'off'].includes(storedLevel)) {
+        globalLogLevel = storedLevel;
+    }
+}
+export function setGlobalLogLevel(level) {
+    globalLogLevel = level;
+    if (typeof localStorage !== 'undefined') {
+        localStorage.setItem('hwc_log_level', level);
+    }
+}
+export function getGlobalLogLevel() {
+    return globalLogLevel;
+}
+// Factory function to create logger instances
+export function createLogger(name, level) {
+    return new DefaultLogger(level || globalLogLevel, name);
+}

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

@@ -1,4 +1,4 @@
-import { AccountId, PublicKey, Transaction, LedgerId, Query, SignerSignature } from '@hashgraph/sdk';
+import { AccountId, PublicKey, PrivateKey, Transaction, LedgerId, Query, SignerSignature } from '@hashgraph/sdk';
 import { ProposalTypes, SessionTypes } from '@walletconnect/types';
 import { proto } from '@hashgraph/proto';
 /**
@@ -273,3 +273,8 @@ export declare const accountAndLedgerFromSession: (session: SessionTypes.Struct)
     network: LedgerId;
     account: AccountId;
 }[];
+/**
+ * Adds an additional signature to an already-signed transaction.
+ * Uses proto-level manipulation to preserve existing signatures.
+ */
+export declare function addSignatureToTransaction<T extends Transaction>(transaction: T, privateKey: PrivateKey): Promise<T>;

package/dist/lib/shared/utils.js

@@ -418,3 +418,44 @@ export const accountAndLedgerFromSession = (session) => {
         };
     });
 };
+/**
+ * Adds an additional signature to an already-signed transaction.
+ * Uses proto-level manipulation to preserve existing signatures.
+ */
+export async function addSignatureToTransaction(transaction, privateKey) {
+    const originalBytes = transaction.toBytes();
+    const originalList = proto.TransactionList.decode(originalBytes);
+    const firstTransaction = originalList.transactionList[0];
+    let bodyBytes;
+    if (firstTransaction.signedTransactionBytes) {
+        const signedTx = proto.SignedTransaction.decode(firstTransaction.signedTransactionBytes);
+        bodyBytes = signedTx.bodyBytes;
+    }
+    else {
+        bodyBytes = firstTransaction.bodyBytes;
+    }
+    const signature = await privateKey.sign(bodyBytes);
+    const publicKey = privateKey.publicKey;
+    const signedTransactionList = originalList.transactionList.map((tx) => {
+        const newSigPair = publicKey._toProtobufSignature(signature);
+        if (tx.signedTransactionBytes) {
+            const signedTx = proto.SignedTransaction.decode(tx.signedTransactionBytes);
+            const existingSigMap = signedTx.sigMap || proto.SignatureMap.create({});
+            const mergedSigPairs = [...(existingSigMap.sigPair || []), newSigPair];
+            const updatedSignedTx = proto.SignedTransaction.encode({
+                bodyBytes: signedTx.bodyBytes,
+                sigMap: proto.SignatureMap.create({ sigPair: mergedSigPairs }),
+            }).finish();
+            return { signedTransactionBytes: updatedSignedTx };
+        }
+        else {
+            const existingSigMap = tx.sigMap || proto.SignatureMap.create({});
+            const mergedSigPairs = [...(existingSigMap.sigPair || []), newSigPair];
+            return Object.assign(Object.assign({}, tx), { sigMap: Object.assign(Object.assign({}, existingSigMap), { sigPair: mergedSigPairs }) });
+        }
+    });
+    const signedBytes = proto.TransactionList.encode({
+        transactionList: signedTransactionList,
+    }).finish();
+    return Transaction.fromBytes(signedBytes);
+}

package/dist/reown/adapter.d.ts

@@ -17,7 +17,7 @@ type GetProfileResult = {
     profileName: string;
 };
 export declare class HederaAdapter extends AdapterBlueprint {
-    private namespaceMode;
+    private logger;
     constructor(params: HederaAdapter.Params);
     setUniversalProvider(universalProvider: UniversalProvider): Promise<void>;
     connect(params: AdapterBlueprint.ConnectParams): Promise<AdapterBlueprint.ConnectResult>;

package/dist/reown/adapter.js

@@ -1,11 +1,11 @@
 import { CoreHelperUtil, WcHelpersUtil } from '@reown/appkit';
 import { isReownName } from '@reown/appkit-common';
 import { AdapterBlueprint } from '@reown/appkit/adapters';
-import { ProviderUtil } from '@reown/appkit/store';
 import { LedgerId } from '@hashgraph/sdk';
 import { BrowserProvider, Contract, formatUnits, JsonRpcSigner, parseUnits } from 'ethers';
 import { HederaConnector } from './connectors';
-import { hederaNamespace, getAccountBalance } from './utils';
+import { hederaNamespace, getAccountBalance, HederaChainDefinition } from './utils';
+import { createLogger } from '../lib/shared/logger';
 export class HederaAdapter extends AdapterBlueprint {
     constructor(params) {
         var _a, _b;
@@ -23,18 +23,47 @@ export class HederaAdapter extends AdapterBlueprint {
             }
         }
         super(Object.assign({}, params));
-        this.namespaceMode = 'optional';
-        this.namespaceMode = params.namespaceMode || 'optional';
+        this.logger = createLogger('HederaAdapter');
+        // Override getCaipNetworks to return appropriate networks based on namespace
+        this.getCaipNetworks = (namespace) => {
+            const targetNamespace = namespace || this.namespace;
+            if (targetNamespace === 'eip155') {
+                // Return EIP155 Hedera networks
+                return [HederaChainDefinition.EVM.Mainnet, HederaChainDefinition.EVM.Testnet];
+            }
+            else if (targetNamespace === hederaNamespace) {
+                // Return native Hedera networks
+                return [HederaChainDefinition.Native.Mainnet, HederaChainDefinition.Native.Testnet];
+            }
+            else {
+                // Return all Hedera networks if no specific namespace is requested
+                return [
+                    HederaChainDefinition.EVM.Mainnet,
+                    HederaChainDefinition.EVM.Testnet,
+                    HederaChainDefinition.Native.Mainnet,
+                    HederaChainDefinition.Native.Testnet,
+                ];
+            }
+        };
     }
     async setUniversalProvider(universalProvider) {
         this.addConnector(new HederaConnector({
             provider: universalProvider,
             caipNetworks: this.getCaipNetworks() || [],
             namespace: this.namespace,
-            namespaceMode: this.namespaceMode,
         }));
     }
     async connect(params) {
+        this.logger.debug('connect called with params:', params);
+        // Get the WalletConnect connector and ensure it connects with proper namespaces
+        const connector = this.getWalletConnectConnector();
+        if (connector && 'connectWalletConnect' in connector) {
+            this.logger.debug('Calling HederaConnector.connectWalletConnect');
+            await connector.connectWalletConnect();
+        }
+        else {
+            this.logger.warn('HederaConnector not found or connectWalletConnect method missing');
+        }
         return Promise.resolve({
             id: 'WALLET_CONNECT',
             type: 'WALLET_CONNECT',
@@ -49,7 +78,7 @@ export class HederaAdapter extends AdapterBlueprint {
             await connector.disconnect();
         }
         catch (error) {
-            console.warn('UniversalAdapter:disconnect - error', error);
+            this.logger.warn('disconnect - error', error);
         }
         return { connections: [] };
     }
@@ -191,7 +220,7 @@ export class HederaAdapter extends AdapterBlueprint {
         if (this.namespace !== 'eip155') {
             throw new Error('Namespace is not eip155');
         }
-        const provider = ProviderUtil.getProvider('eip155');
+        const provider = this.provider;
         if (!provider) {
             throw new Error('Provider is undefined');
         }

package/dist/reown/connectors/HederaConnector.d.ts

@@ -10,8 +10,7 @@ export declare class HederaConnector implements ChainAdapterConnector {
     readonly chain: ChainNamespace;
     provider: UniversalProvider;
     protected caipNetworks: CaipNetwork[];
-    protected namespaceMode: 'optional' | 'required';
-    constructor({ provider, caipNetworks, namespace, namespaceMode, }: HederaConnector.Options);
+    constructor({ provider, caipNetworks, namespace }: HederaConnector.Options);
     get chains(): CaipNetwork[];
     connectWalletConnect(): Promise<{
         clientId: string;
@@ -25,7 +24,6 @@ export declare namespace HederaConnector {
         provider: UniversalProvider;
         caipNetworks: CaipNetwork[];
         namespace: 'hedera' | 'eip155';
-        namespaceMode?: 'optional' | 'required';
     };
 }
 export {};

package/dist/reown/connectors/HederaConnector.js

@@ -2,7 +2,7 @@ import { ConstantsUtil } from '@reown/appkit-common';
 import { PresetsUtil } from '@reown/appkit-utils';
 import { createNamespaces } from '../utils';
 export class HederaConnector {
-    constructor({ provider, caipNetworks, namespace, namespaceMode = 'optional', }) {
+    constructor({ provider, caipNetworks, namespace }) {
         this.id = ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT;
         this.name = PresetsUtil.ConnectorNamesMap[ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT];
         this.type = 'WALLET_CONNECT';
@@ -10,20 +10,14 @@ export class HederaConnector {
         this.caipNetworks = caipNetworks;
         this.provider = provider;
         this.chain = namespace;
-        this.namespaceMode = namespaceMode;
     }
     get chains() {
         return this.caipNetworks;
     }
     async connectWalletConnect() {
-        const isAuthenticated = await this.authenticate();
-        if (!isAuthenticated) {
-            const namespaces = createNamespaces(this.caipNetworks);
-            const connectParams = this.namespaceMode === 'required'
-                ? { requiredNamespaces: namespaces }
-                : { optionalNamespaces: namespaces };
-            await this.provider.connect(connectParams);
-        }
+        const namespaces = createNamespaces(this.caipNetworks);
+        const connectParams = { optionalNamespaces: namespaces };
+        await this.provider.connect(connectParams);
         return {
             clientId: await this.provider.client.core.crypto.getClientId(),
             session: this.provider.session,

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

@@ -8,6 +8,7 @@ declare class EIP155Provider implements IProvider {
     namespace: SessionNamespace;
     httpProviders: RpcProvidersMap;
     events: EventEmitter;
+    private logger;
     constructor({ client, events, namespace, }: {
         client: IProvider['client'];
         events: EventEmitter;

package/dist/reown/providers/EIP155Provider.js

@@ -2,9 +2,11 @@ import { JsonRpcProvider } from '@walletconnect/jsonrpc-provider';
 import { HttpConnection } from '@walletconnect/jsonrpc-http-connection';
 import { formatJsonRpcRequest } from '@walletconnect/jsonrpc-utils';
 import { BUNDLER_URL, getChainId, HederaChainDefinition } from '../utils';
+import { createLogger } from '../../lib/shared/logger';
 class EIP155Provider {
     constructor({ client, events, namespace, }) {
         this.name = 'eip155';
+        this.logger = createLogger('EIP155Provider');
         this.namespace = namespace;
         this.events = events;
         this.client = client;
@@ -51,9 +53,7 @@ class EIP155Provider {
             return this.chainId.toString();
         if (this.namespace.defaultChain)
             return this.namespace.defaultChain;
-        const chainId = this.namespace.chains[0];
-        if (!chainId)
-            throw new Error(`ChainId not found`);
+        const chainId = this.namespace.chains[0] || 'eip155:295'; // default to mainnet
         return chainId.split(':')[1];
     }
     // ---------- Private ----------------------------------------------- //
@@ -146,7 +146,7 @@ class EIP155Provider {
                 return await this.getUserOperationReceipt(bundlerUrl, args);
             }
             catch (error) {
-                console.warn('Failed to fetch call status from bundler', error, bundlerUrl);
+                this.logger.warn('Failed to fetch call status from bundler', error, bundlerUrl);
             }
         }
         const customUrl = (_b = session.sessionProperties) === null || _b === void 0 ? void 0 : _b.bundler_url;
@@ -155,7 +155,7 @@ class EIP155Provider {
                 return await this.getUserOperationReceipt(customUrl, args);
             }
             catch (error) {
-                console.warn('Failed to fetch call status from custom bundler', error, customUrl);
+                this.logger.warn('Failed to fetch call status from custom bundler', error, customUrl);
             }
         }
         if (this.namespace.methods.includes(args.request.method)) {

package/dist/reown/providers/HIP820Provider.js

@@ -42,9 +42,7 @@ class HIP820Provider {
             return this.chainId;
         if (this.namespace.defaultChain)
             return this.namespace.defaultChain;
-        const chainId = this.namespace.chains[0];
-        if (!chainId)
-            throw new Error(`ChainId not found`);
+        const chainId = this.namespace.chains[0] || 'hedera:mainnet'; // default to mainnet
         return chainId.split(':')[1];
     }
     // create signer on demand

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

@@ -11,6 +11,7 @@ export type HederaWalletConnectProviderConfig = {
     chains: CaipNetwork[];
 } & UniversalProviderOpts;
 export declare class HederaProvider extends UniversalProvider {
+    private hederaLogger;
     nativeProvider?: HIP820Provider;
     eip155Provider?: EIP155Provider;
     constructor(opts: UniversalProviderOpts);
@@ -157,6 +158,7 @@ export declare class HederaProvider extends UniversalProvider {
     net_version(): Promise<string>;
     web3_clientVersion(): Promise<string>;
     eth_chainId(): Promise<string>;
+    connect(params?: any): Promise<any>;
     pair(pairingTopic: string | undefined): ReturnType<UniversalProvider['pair']>;
     private initProviders;
     get rpcProviders(): RpcProviderMap;

package/dist/reown/providers/HederaProvider.js

@@ -5,25 +5,19 @@ import { HederaJsonRpcMethod, } from '../..';
 import { getChainsFromApprovedSession, mergeRequiredOptionalNamespaces, } from '../utils';
 import HIP820Provider from './HIP820Provider';
 import EIP155Provider from './EIP155Provider';
+import { createLogger } from '../../lib/shared/logger';
 // Reown AppKit UniversalProvider for HIP-820 & EIP-155 version implementation of the @hashgraph/hedera-wallet-connect DAppConnector
 export class HederaProvider extends UniversalProvider {
     constructor(opts) {
         super(opts);
+        this.hederaLogger = createLogger('HederaProvider');
     }
     static async init(opts) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b;
         const provider = new HederaProvider(opts);
-        //@ts-expect-error - private base method
+        //@ts-expect-error
         await provider.initialize();
-        provider.namespaces = Object.assign(Object.assign({}, (((_a = provider.namespaces) === null || _a === void 0 ? void 0 : _a.eip155)
-            ? {
-                eip155: Object.assign(Object.assign({}, (_b = provider.namespaces) === null || _b === void 0 ? void 0 : _b.eip155), { rpcMap: (_c = provider.optionalNamespaces) === null || _c === void 0 ? void 0 : _c.eip155.rpcMap }),
-            }
-            : {})), (((_d = provider.namespaces) === null || _d === void 0 ? void 0 : _d.hedera)
-            ? {
-                hedera: Object.assign(Object.assign({}, (_e = provider.namespaces) === null || _e === void 0 ? void 0 : _e.hedera), { rpcMap: (_f = provider.optionalNamespaces) === null || _f === void 0 ? void 0 : _f.hedera.rpcMap }),
-            }
-            : {}));
+        provider.namespaces = Object.assign(Object.assign({}, (((_a = provider.providerOpts) === null || _a === void 0 ? void 0 : _a.optionalNamespaces) || {})), (((_b = provider.providerOpts) === null || _b === void 0 ? void 0 : _b.requiredNamespaces) || {}));
         if (provider.session)
             provider.initProviders();
         return provider;
@@ -32,13 +26,13 @@ export class HederaProvider extends UniversalProvider {
         this.events.emit(event, data);
     }
     getAccountAddresses() {
-        if (!this.session || !this.namespaces) {
+        if (!this.session) {
             throw new Error('Not initialized. Please call connect()');
         }
         return Object.values(this.session.namespaces).flatMap((namespace) => { var _a; return (_a = namespace.accounts.map((account) => account.split(':')[2])) !== null && _a !== void 0 ? _a : []; });
     }
     async request(args, chain, expiry) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         if (!this.session || !this.namespaces) {
             throw new Error('Please call connect() before request()');
         }
@@ -59,8 +53,8 @@ export class HederaProvider extends UniversalProvider {
             if (!this.eip155Provider) {
                 throw new Error('eip155Provider not initialized');
             }
-            chainId = chainId !== null && chainId !== void 0 ? chainId : (_c = this.namespaces.eip155) === null || _c === void 0 ? void 0 : _c.chains[0];
-            return (_d = this.eip155Provider) === null || _d === void 0 ? void 0 : _d.request({
+            chainId = chainId !== null && chainId !== void 0 ? chainId : (_d = (_c = this.namespaces) === null || _c === void 0 ? void 0 : _c.eip155) === null || _d === void 0 ? void 0 : _d.chains[0];
+            return (_e = this.eip155Provider) === null || _e === void 0 ? void 0 : _e.request({
                 request: Object.assign({}, args),
                 chainId: chainId,
                 topic: this.session.topic,
@@ -411,7 +405,45 @@ export class HederaProvider extends UniversalProvider {
     async eth_chainId() {
         return this.request({ method: 'eth_chainId', params: [] });
     }
+    async connect(params) {
+        this.hederaLogger.debug('connect called with params:', params);
+        // Update the internal namespace properties before connecting
+        if (params) {
+            if (params.requiredNamespaces) {
+                this.hederaLogger.debug('Setting requiredNamespaces:', params.requiredNamespaces);
+                // @ts-ignore - accessing private property
+                this.requiredNamespaces = params.requiredNamespaces;
+            }
+            if (params.optionalNamespaces) {
+                this.hederaLogger.debug('Setting optionalNamespaces:', params.requiredNamespaces);
+                // @ts-ignore - accessing private property
+                this.optionalNamespaces = params.optionalNamespaces;
+            }
+            if (params.namespaces) {
+                this.hederaLogger.debug('Setting namespaces:', params.namespaces);
+                // @ts-ignore - accessing private property
+                this.namespaces = params.namespaces;
+            }
+        }
+        this.hederaLogger.debug('Calling super.connect with params');
+        // Try to directly pass the namespaces to the parent connect
+        let result;
+        try {
+            result = await super.connect(params);
+        }
+        catch (error) {
+            this.hederaLogger.error('Error in super.connect:', error);
+            throw error;
+        }
+        this.hederaLogger.info('super.connect completed successfully');
+        this.hederaLogger.debug('Result from super.connect:', result);
+        this.initProviders();
+        return result;
+    }
     async pair(pairingTopic) {
+        console.log(pairingTopic);
+        //@ts-expect-error
+        console.log(this.requiredNamespaces);
         const session = await super.pair(pairingTopic);
         this.initProviders();
         return session;
@@ -426,10 +458,13 @@ export class HederaProvider extends UniversalProvider {
         const namespaces = Object.keys(this.namespaces);
         const providers = {};
         namespaces.forEach((namespace) => {
-            const accounts = this.session.namespaces[namespace].accounts;
+            var _a, _b, _c, _d;
+            const accounts = ((_b = (_a = this.session) === null || _a === void 0 ? void 0 : _a.namespaces[namespace]) === null || _b === void 0 ? void 0 : _b.accounts) || [];
             const approvedChains = getChainsFromApprovedSession(accounts);
             const mergedNamespaces = mergeRequiredOptionalNamespaces(this.namespaces, this.optionalNamespaces);
-            const combinedNamespace = Object.assign(Object.assign({}, mergedNamespaces[namespace]), { accounts, chains: approvedChains });
+            const combinedNamespace = Object.assign(Object.assign(Object.assign({}, mergedNamespaces[namespace]), { accounts, chains: approvedChains }), (((_d = (_c = this.optionalNamespaces) === null || _c === void 0 ? void 0 : _c[namespace]) === null || _d === void 0 ? void 0 : _d.rpcMap) && {
+                rpcMap: this.optionalNamespaces[namespace].rpcMap,
+            }));
             switch (namespace) {
                 case 'hedera': {
                     const provider = new HIP820Provider({

package/dist/reown/utils/account.js

@@ -1,20 +1,41 @@
 import { AccountBalanceQuery, AccountId, Client, LedgerId, } from '@hashgraph/sdk';
+import { createLogger } from '../../lib/shared/logger';
+const logger = createLogger('AccountUtils');
 export async function getAccountBalance(ledgerId, address) {
     const client = ledgerId === LedgerId.TESTNET ? Client.forTestnet() : Client.forMainnet();
     let accountId;
     try {
+        // First try to parse as a Hedera account ID (e.g., "0.0.12345")
         accountId = AccountId.fromString(address);
     }
     catch (e) {
-        accountId = AccountId.fromEvmAddress(0, 0, address);
-    }
-    if (accountId.num.isZero() && accountId.evmAddress != null) {
-        await accountId.populateAccountNum(client);
+        // If it's an EVM address (starts with 0x), try to get the associated account
+        if (address.startsWith('0x')) {
+            try {
+                accountId = AccountId.fromEvmAddress(0, 0, address);
+                // Try to populate the account number from the mirror node
+                // This will fail if the EVM address doesn't have an associated Hedera account
+                if (accountId.num.isZero() && accountId.evmAddress != null) {
+                    await accountId.populateAccountNum(client);
+                }
+            }
+            catch (populateError) {
+                // If we can't find a Hedera account for this EVM address, return null
+                logger.debug('No Hedera account found for EVM address:', address);
+                return null;
+            }
+        }
+        else {
+            // Not a valid account ID or EVM address
+            logger.debug('Invalid address format:', address);
+            return null;
+        }
     }
     try {
         return await new AccountBalanceQuery().setAccountId(accountId).execute(client);
     }
     catch (e) {
+        logger.debug('Failed to get account balance:', e);
         return null;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hashgraph/hedera-wallet-connect",
-  "version": "2.0.4-canary.f71fa76.0",
+  "version": "2.0.5-canary.7b24ac9.0",
   "description": "A library to facilitate integrating Hedera with WalletConnect",
   "repository": {
     "type": "git",
@@ -38,6 +38,7 @@
     "@swc/jest": "^0.2.37",
     "@types/jest": "^30.0.0",
     "jest": "^30.0.3",
+    "nodemon": "^3.1.10",
     "prettier": "^3.5.3",
     "ts-node": "^10.9.2",
     "typescript": "^5.8.2"