@hashgraph/hedera-wallet-connect 2.0.3-canary.cf4c7e1.0 → 2.0.3

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@2.0.4-canary.3ca04e9.0 @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
 
@@ -215,7 +215,6 @@ createAppKit({
 
 - [Hashpack](https://hashpack.app/)
 - [Kabila](https://wallet.kabila.app/)
-- [Blade](https://bladewallet.io/)
 - [Dropp](https://dropp.cc/)
 
 # Upgrading from v1 to v2

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/reown/adapter.d.ts

@@ -17,7 +17,8 @@ type GetProfileResult = {
     profileName: string;
 };
 export declare class HederaAdapter extends AdapterBlueprint {
-    constructor(params: AdapterBlueprint.Params);
+    private logger;
+    constructor(params: HederaAdapter.Params);
     setUniversalProvider(universalProvider: UniversalProvider): Promise<void>;
     connect(params: AdapterBlueprint.ConnectParams): Promise<AdapterBlueprint.ConnectResult>;
     disconnect(_params?: AdapterBlueprint.DisconnectParams): Promise<AdapterBlueprint.DisconnectResult>;
@@ -50,4 +51,9 @@ export declare class HederaAdapter extends AdapterBlueprint {
     getWalletConnectProvider(): UniversalProvider;
     walletGetAssets(_params: AdapterBlueprint.WalletGetAssetsParams): Promise<AdapterBlueprint.WalletGetAssetsResponse>;
 }
+export declare namespace HederaAdapter {
+    type Params = AdapterBlueprint.Params & {
+        namespaceMode?: 'optional' | 'required';
+    };
+}
 export {};

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,6 +23,28 @@ export class HederaAdapter extends AdapterBlueprint {
             }
         }
         super(Object.assign({}, params));
+        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({
@@ -32,6 +54,16 @@ export class HederaAdapter extends AdapterBlueprint {
         }));
     }
     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',
@@ -46,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: [] };
     }
@@ -188,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.js

@@ -15,12 +15,9 @@ export class HederaConnector {
         return this.caipNetworks;
     }
     async connectWalletConnect() {
-        const isAuthenticated = await this.authenticate();
-        if (!isAuthenticated) {
-            await this.provider.connect({
-                optionalNamespaces: createNamespaces(this.caipNetworks),
-            });
-        }
+        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.3-canary.cf4c7e1.0",
+  "version": "2.0.3",
   "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"