@hashgraph/hedera-wallet-connect 2.0.3-canary.8d1953d.0 → 2.0.4-canary.46d8648.0

package/README.md

@@ -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

@@ -6,6 +6,7 @@ import { LedgerId } from '@hashgraph/sdk';
 import { BrowserProvider, Contract, formatUnits, JsonRpcSigner, parseUnits } from 'ethers';
 import { HederaConnector } from './connectors';
 import { hederaNamespace, getAccountBalance } from './utils';
+import { createLogger } from '../lib/shared/logger';
 export class HederaAdapter extends AdapterBlueprint {
     constructor(params) {
         var _a, _b;
@@ -23,6 +24,7 @@ export class HederaAdapter extends AdapterBlueprint {
             }
         }
         super(Object.assign({}, params));
+        this.logger = createLogger('HederaAdapter');
     }
     async setUniversalProvider(universalProvider) {
         this.addConnector(new HederaConnector({
@@ -32,6 +34,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 +58,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: [] };
     }

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

@@ -10,6 +10,7 @@ export declare class HederaConnector implements ChainAdapterConnector {
     readonly chain: ChainNamespace;
     provider: UniversalProvider;
     protected caipNetworks: CaipNetwork[];
+    private logger;
     constructor({ provider, caipNetworks, namespace }: HederaConnector.Options);
     get chains(): CaipNetwork[];
     connectWalletConnect(): Promise<{

package/dist/reown/connectors/HederaConnector.js

@@ -1,12 +1,14 @@
 import { ConstantsUtil } from '@reown/appkit-common';
 import { PresetsUtil } from '@reown/appkit-utils';
 import { createNamespaces } from '../utils';
+import { createLogger } from '../../lib/shared/logger';
 export class HederaConnector {
     constructor({ provider, caipNetworks, namespace }) {
         this.id = ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT;
         this.name = PresetsUtil.ConnectorNamesMap[ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT];
         this.type = 'WALLET_CONNECT';
         this.imageId = PresetsUtil.ConnectorImageIds[ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT];
+        this.logger = createLogger('HederaConnector');
         this.caipNetworks = caipNetworks;
         this.provider = provider;
         this.chain = namespace;
@@ -15,11 +17,53 @@ export class HederaConnector {
         return this.caipNetworks;
     }
     async connectWalletConnect() {
+        var _a, _b, _c;
+        this.logger.debug('connectWalletConnect called for', this.chain);
+        this.logger.debug('Provider type:', (_b = (_a = this.provider) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name);
+        this.logger.debug('Provider session exists:', !!((_c = this.provider) === null || _c === void 0 ? void 0 : _c.session));
         const isAuthenticated = await this.authenticate();
+        this.logger.debug('Is authenticated:', isAuthenticated);
         if (!isAuthenticated) {
-            await this.provider.connect({
-                optionalNamespaces: createNamespaces(this.caipNetworks),
+            // Check for stored connection params from the dApp
+            let connectParams = undefined;
+            this.logger.debug('Checking for stored params');
+            if (typeof window !== 'undefined' && window.sessionStorage) {
+                const storedParams = sessionStorage.getItem('hwcV2ConnectionParams');
+                this.logger.debug('Stored params in sessionStorage:', storedParams);
+                if (storedParams) {
+                    try {
+                        connectParams = JSON.parse(storedParams);
+                        this.logger.info('Using stored connection params from dApp in connector:', connectParams);
+                        // Don't clear here - let the provider handle it
+                    }
+                    catch (e) {
+                        this.logger.warn('Failed to parse stored connection params in connector:', e);
+                    }
+                }
+            }
+            // If no stored params, create default namespaces
+            if (!connectParams) {
+                const namespaces = createNamespaces(this.caipNetworks);
+                connectParams = { optionalNamespaces: namespaces };
+                this.logger.debug('No stored params, using default namespaces:', connectParams);
+            }
+            this.logger.debug('Connecting with params:', {
+                namespace: this.chain,
+                caipNetworks: this.caipNetworks.map((n) => ({
+                    id: n.id,
+                    chainNamespace: n.chainNamespace,
+                    caipNetworkId: n.caipNetworkId,
+                    name: n.name,
+                })),
+                connectParams,
             });
+            this.logger.debug('Final params before provider.connect:', connectParams);
+            this.logger.debug('Calling provider.connect with params');
+            await this.provider.connect(connectParams);
+            this.logger.info('Provider.connect completed successfully');
+        }
+        else {
+            this.logger.info('Already authenticated, skipping namespace setup');
         }
         return {
             clientId: await this.provider.client.core.crypto.getClientId(),

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;
@@ -146,7 +148,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 +157,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/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,23 +5,25 @@ 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, _c, _d, _e, _f, _g, _h;
         const provider = new HederaProvider(opts);
         //@ts-expect-error - private base method
         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 }),
+                eip155: Object.assign(Object.assign({}, (_b = provider.namespaces) === null || _b === void 0 ? void 0 : _b.eip155), { rpcMap: ((_d = (_c = provider.optionalNamespaces) === null || _c === void 0 ? void 0 : _c.eip155) === null || _d === void 0 ? void 0 : _d.rpcMap) || {} }),
             }
-            : {})), (((_d = provider.namespaces) === null || _d === void 0 ? void 0 : _d.hedera)
+            : {})), (((_e = provider.namespaces) === null || _e === void 0 ? void 0 : _e.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 }),
+                hedera: Object.assign(Object.assign({}, (_f = provider.namespaces) === null || _f === void 0 ? void 0 : _f.hedera), { rpcMap: ((_h = (_g = provider.optionalNamespaces) === null || _g === void 0 ? void 0 : _g.hedera) === null || _h === void 0 ? void 0 : _h.rpcMap) || {} }),
             }
             : {}));
         if (provider.session)
@@ -411,6 +413,84 @@ 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);
+        // Check for stored connection params from the dApp
+        if (!params || (!params.requiredNamespaces && !params.optionalNamespaces)) {
+            // Try to get params from sessionStorage (set by the dApp)
+            if (typeof window !== 'undefined' && window.sessionStorage) {
+                const storedParams = sessionStorage.getItem('hwcV2ConnectionParams');
+                this.hederaLogger.debug('Stored params in sessionStorage:', storedParams);
+                if (storedParams) {
+                    try {
+                        params = JSON.parse(storedParams);
+                        this.hederaLogger.info('Using stored connection params from dApp:', params);
+                        // Clear the stored params after using them
+                        sessionStorage.removeItem('hwcV2ConnectionParams');
+                    }
+                    catch (e) {
+                        this.hederaLogger.warn('Failed to parse stored connection params:', e);
+                    }
+                }
+            }
+        }
+        // If still no params provided or empty namespaces, create default namespaces
+        if (!params || (!params.requiredNamespaces && !params.optionalNamespaces)) {
+            this.hederaLogger.info('No namespaces provided, creating default namespaces');
+            // Create default namespaces based on initialized state
+            const defaultNamespaces = {
+                hedera: {
+                    methods: Object.values(HederaJsonRpcMethod),
+                    chains: ['hedera:testnet', 'hedera:mainnet'],
+                    events: ['accountsChanged', 'chainChanged'],
+                },
+                eip155: {
+                    methods: [
+                        'eth_sendTransaction',
+                        'eth_signTransaction',
+                        'eth_sign',
+                        'personal_sign',
+                        'eth_signTypedData',
+                        'eth_signTypedData_v4',
+                        'eth_accounts',
+                        'eth_chainId',
+                    ],
+                    chains: ['eip155:296', 'eip155:295'],
+                    events: ['accountsChanged', 'chainChanged'],
+                },
+            };
+            params = Object.assign({ requiredNamespaces: defaultNamespaces }, params);
+            this.hederaLogger.debug('Using default namespaces:', params.requiredNamespaces);
+        }
+        this.hederaLogger.debug('Final params before super.connect:', 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.optionalNamespaces);
+                // @ts-ignore - accessing private property
+                this.optionalNamespaces = params.optionalNamespaces;
+            }
+        }
+        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) {
         const session = await super.pair(pairingTopic);
         this.initProviders();

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.8d1953d.0",
+  "version": "2.0.4-canary.46d8648.0",
   "description": "A library to facilitate integrating Hedera with WalletConnect",
   "repository": {
     "type": "git",