@hashgraph/hedera-wallet-connect 2.0.1-canary.240df79.0 → 2.0.1-canary.25d7f01.0

package/dist/index.d.ts

@@ -1 +1,2 @@
 export * from './lib';
+export * from './reown';

package/dist/index.js

@@ -18,3 +18,4 @@
  *
  */
 export * from './lib';
+export * from './reown';

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

@@ -8,6 +8,7 @@ export declare class DAppSigner implements Signer {
     private readonly ledgerId;
     readonly extensionId?: string | undefined;
     private logger;
+    private publicKey;
     constructor(accountId: AccountId, signClient: ISignClient, topic: string, ledgerId?: LedgerId, extensionId?: string | undefined, logLevel?: LogLevel);
     /**
      * Sets the logging level for the DAppSigner
@@ -22,6 +23,7 @@ export declare class DAppSigner implements Signer {
     }): Promise<T>;
     getAccountId(): AccountId;
     getAccountKey(): Key;
+    getAccountKeyAsync(): Promise<Key | null>;
     getLedgerId(): LedgerId;
     getNetwork(): {
         [key: string]: string | AccountId;

package/dist/lib/dapp/DAppSigner.js

@@ -19,7 +19,7 @@
  */
 import { AccountBalance, AccountInfo, LedgerId, SignerSignature, Transaction, TransactionRecord, Client, PublicKey, TransactionId, TransactionResponse, Query, AccountRecordsQuery, AccountInfoQuery, AccountBalanceQuery, TransactionReceiptQuery, TransactionReceipt, TransactionRecordQuery, } from '@hashgraph/sdk';
 import { proto } from '@hashgraph/proto';
-import { HederaJsonRpcMethod, base64StringToSignatureMap, base64StringToUint8Array, ledgerIdToCAIPChainId, queryToBase64String, transactionBodyToBase64String, transactionToBase64String, transactionToTransactionBody, extensionOpen, Uint8ArrayToBase64String, Uint8ArrayToString, } from '../shared';
+import { HederaJsonRpcMethod, base64StringToSignatureMap, base64StringToUint8Array, ledgerIdToCAIPChainId, queryToBase64String, transactionBodyToBase64String, transactionToBase64String, transactionToTransactionBody, extensionOpen, Uint8ArrayToBase64String, Uint8ArrayToString, getAccountInfo, } from '../shared';
 import { DefaultLogger } from '../shared/logger';
 import { SessionNotFoundError } from './SessionNotFoundError';
 const clients = {};
@@ -31,6 +31,11 @@ export class DAppSigner {
         this.ledgerId = ledgerId;
         this.extensionId = extensionId;
         this.logger = new DefaultLogger(logLevel);
+        this.publicKey = null;
+        // cache public key from mirror node
+        this.getAccountKeyAsync()
+            .then((key) => (this.publicKey = key))
+            .catch((error) => this.logger.error('Error when receiving a public key:', error.message));
     }
     /**
      * Sets the logging level for the DAppSigner
@@ -79,7 +84,16 @@ export class DAppSigner {
         return this.accountId;
     }
     getAccountKey() {
-        throw new Error('Method not implemented.');
+        if (this.publicKey == null) {
+            throw new Error('No key was received from the mirror node');
+        }
+        return this.publicKey;
+    }
+    async getAccountKeyAsync() {
+        const accountInfo = await getAccountInfo(this.ledgerId, this.accountId.toString());
+        if (!(accountInfo === null || accountInfo === void 0 ? void 0 : accountInfo.key))
+            return null;
+        return PublicKey.fromString(accountInfo.key.key);
     }
     getLedgerId() {
         return this.ledgerId;

package/dist/lib/dapp/index.d.ts

@@ -1,15 +1,17 @@
 import { AccountId, LedgerId, Transaction } from '@hashgraph/sdk';
-import { SessionTypes, SignClientTypes } from '@walletconnect/types';
+import { EngineTypes, SessionTypes, SignClientTypes } from '@walletconnect/types';
 import { WalletConnectModal } from '@walletconnect/modal';
 import SignClient from '@walletconnect/sign-client';
 import { LogLevel } from '../shared/logger';
 import { GetNodeAddressesResult, ExecuteTransactionParams, ExecuteTransactionResult, SignMessageParams, SignMessageResult, SignAndExecuteQueryResult, SignAndExecuteQueryParams, SignAndExecuteTransactionParams, SignAndExecuteTransactionResult, SignTransactionParams, SignTransactionResult, ExtensionData } from '../shared';
 import { DAppSigner } from './DAppSigner';
+import { JsonRpcResult } from '@walletconnect/jsonrpc-types';
 export * from './DAppSigner';
 export { SessionNotFoundError } from './SessionNotFoundError';
 type BaseLogger = 'error' | 'warn' | 'info' | 'debug' | 'trace' | 'fatal';
 export declare class DAppConnector {
     private logger;
+    readonly storagePrefix = "hedera-wc/dapp-connector/";
     dAppMetadata: SignClientTypes.Metadata;
     network: LedgerId;
     projectId: string;
@@ -106,7 +108,7 @@ export declare class DAppConnector {
     private createSigners;
     private onSessionConnected;
     private connectURI;
-    private request;
+    request<Req extends EngineTypes.RequestParams, Res extends JsonRpcResult>({ method, params, }: Req['request']): Promise<Res>;
     /**
      * Retrieves the node addresses associated with the current Hedera network.
      *
@@ -192,9 +194,7 @@ export declare class DAppConnector {
      *
      * @param {SignTransactionParams} params - The parameters of type {@link SignTransactionParams | `SignTransactionParams`} required for `Transaction` signing.
      * @param {string} params.signerAccountId - a signer Hedera Account identifier in {@link https://hips.hedera.com/hip/hip-30 | HIP-30} (`<nework>:<shard>.<realm>.<num>`) form.
-     * @param {Transaction | string} params.transactionBody - a built Transaction object, or a base64 string of a transaction body( HIP-820).
-     * HIP-820 calls for a base64 encoded proto.TransactionBody and many wallets support a serialized Transaction object generated by the Hedera Javascript SDK.
-     * Both options are supported here for backwards compatibility.
+     * @param {Transaction} params.transactionBody - a Transaction object built with the @hashgraph/sdk
      * @returns Promise\<{@link SignTransactionResult}\>
      * @example
      * ```ts
@@ -212,5 +212,7 @@ export declare class DAppConnector {
     private handleSessionUpdate;
     private handleSessionDelete;
     private handlePairingDelete;
+    private handleRelayConnected;
+    private verifyLastConnectedInstance;
 }
 export default DAppConnector;

package/dist/lib/dapp/index.js

@@ -20,7 +20,8 @@
 import { LedgerId, Transaction } from '@hashgraph/sdk';
 import { WalletConnectModal } from '@walletconnect/modal';
 import SignClient from '@walletconnect/sign-client';
-import { getSdkError } from '@walletconnect/utils';
+import { getSdkError, isOnline } from '@walletconnect/utils';
+import { RELAYER_EVENTS } from '@walletconnect/core';
 import { DefaultLogger } from '../shared/logger';
 import { HederaJsonRpcMethod, accountAndLedgerFromSession, networkNamespaces, extensionConnect, findExtensions, } from '../shared';
 import { DAppSigner } from './DAppSigner';
@@ -38,6 +39,7 @@ export class DAppConnector {
      * @param logLevel - Logging level for the DAppConnector (optional).
      */
     constructor(metadata, network, projectId, methods, events, chains, logLevel = 'debug') {
+        this.storagePrefix = 'hedera-wc/dapp-connector/';
         this.network = LedgerId.TESTNET;
         this.supportedMethods = [];
         this.supportedEvents = [];
@@ -110,6 +112,9 @@ export class DAppConnector {
                 this.signers = existingSessions.flatMap((session) => this.createSigners(session));
             else
                 this.checkIframeConnect();
+            //manual call after init before relayer connect event handler is attached
+            this.handleRelayConnected();
+            this.walletConnectClient.core.relayer.on(RELAYER_EVENTS.connect, this.handleRelayConnected.bind(this));
             this.walletConnectClient.on('session_event', this.handleSessionEvent.bind(this));
             this.walletConnectClient.on('session_update', this.handleSessionUpdate.bind(this));
             this.walletConnectClient.on('session_delete', this.handleSessionDelete.bind(this));
@@ -379,6 +384,7 @@ export class DAppConnector {
         if (!signer) {
             throw new Error('There is no active session. Connect to the wallet at first.');
         }
+        await this.verifyLastConnectedInstance();
         this.logger.debug(`Using signer: ${signer.getAccountId().toString()}: ${signer.topic} - about to request.`);
         return await signer.request({
             method: method,
@@ -495,9 +501,7 @@ export class DAppConnector {
      *
      * @param {SignTransactionParams} params - The parameters of type {@link SignTransactionParams | `SignTransactionParams`} required for `Transaction` signing.
      * @param {string} params.signerAccountId - a signer Hedera Account identifier in {@link https://hips.hedera.com/hip/hip-30 | HIP-30} (`<nework>:<shard>.<realm>.<num>`) form.
-     * @param {Transaction | string} params.transactionBody - a built Transaction object, or a base64 string of a transaction body( HIP-820).
-     * HIP-820 calls for a base64 encoded proto.TransactionBody and many wallets support a serialized Transaction object generated by the Hedera Javascript SDK.
-     * Both options are supported here for backwards compatibility.
+     * @param {Transaction} params.transactionBody - a Transaction object built with the @hashgraph/sdk
      * @returns Promise\<{@link SignTransactionResult}\>
      * @example
      * ```ts
@@ -576,5 +580,33 @@ export class DAppConnector {
         }
         this.logger.info('Pairing deleted by wallet');
     }
+    // Store the last connected randomSessionIdentifier
+    async handleRelayConnected() {
+        if (!this.walletConnectClient) {
+            this.logger.error('walletConnectClient not found');
+            return;
+        }
+        const core = this.walletConnectClient.core;
+        const instanceId = core.crypto.randomSessionIdentifier;
+        await core.storage.setItem(this.storagePrefix + 'last-connected-instance', instanceId);
+    }
+    // In the event of another tab being connected after the current one,
+    // the current tab will be forcibly reconnected to the relay so that
+    // a response to the request can be received.
+    // https://github.com/hashgraph/hedera-wallet-connect/issues/387
+    async verifyLastConnectedInstance() {
+        if (!this.walletConnectClient) {
+            this.logger.error('walletConnectClient not found');
+            return;
+        }
+        const core = this.walletConnectClient.core;
+        const instanceId = core.crypto.randomSessionIdentifier;
+        const isOnlineStatus = await isOnline();
+        const lastConnectedInstanceId = await core.storage.getItem(this.storagePrefix + 'last-connected-instance');
+        if (lastConnectedInstanceId != instanceId && isOnlineStatus) {
+            this.logger.info('Forced reconnecting to the relay');
+            await core.relayer.restartTransport();
+        }
+    }
 }
 export default DAppConnector;

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

@@ -0,0 +1,30 @@
+export interface AccountInfo {
+    account: string;
+    alias: string;
+    auto_renew_period: number;
+    balance: Balance;
+    created_timestamp: string;
+    decline_reward: boolean;
+    deleted: boolean;
+    ethereum_nonce: number;
+    evm_address: string;
+    expiry_timestamp: string;
+    key: Key | null;
+    max_automatic_token_associations: number;
+    memo: string;
+    pending_reward: number;
+    receiver_sig_required: boolean;
+}
+export interface Balance {
+    balance: number;
+    timestamp: string;
+    tokens: Token[];
+}
+export interface Token {
+    token_id: string;
+    balance: number;
+}
+export interface Key {
+    _type: string;
+    key: string;
+}

package/dist/lib/shared/accountInfo.js

@@ -0,0 +1 @@
+export {};

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

@@ -5,3 +5,5 @@ export * from './methods';
 export * from './payloads';
 export * from './utils';
 export * from './extensionController';
+export * from './mirrorNode';
+export * from './accountInfo';

package/dist/lib/shared/index.js

@@ -24,3 +24,5 @@ export * from './methods';
 export * from './payloads';
 export * from './utils';
 export * from './extensionController';
+export * from './mirrorNode';
+export * from './accountInfo';

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

@@ -0,0 +1,3 @@
+import { LedgerId } from '@hashgraph/sdk';
+import { AccountInfo } from '.';
+export declare function getAccountInfo(ledgerId: LedgerId, address: string): Promise<AccountInfo | null>;

package/dist/lib/shared/mirrorNode.js

@@ -0,0 +1,17 @@
+function getMirrorNodeUrl(ledgerId) {
+    return `https://${ledgerId.toString()}.mirrornode.hedera.com`;
+}
+export async function getAccountInfo(ledgerId, address) {
+    const mirrorNodeApiUrl = getMirrorNodeUrl(ledgerId);
+    const url = `${mirrorNodeApiUrl}/api/v1/accounts/${address}`;
+    const result = await fetch(url, {
+        headers: {
+            accept: 'application/json',
+        },
+    });
+    if (result.status !== 200) {
+        return null;
+    }
+    const response = await result.json();
+    return response;
+}

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

@@ -84,7 +84,7 @@ export interface SignAndExecuteTransactionResponse extends EngineTypes.RespondPa
 }
 export interface SignTransactionParams {
     signerAccountId: string;
-    transactionBody: Transaction | string;
+    transactionBody: Transaction;
 }
 export interface SignTransactionRequest extends EngineTypes.RequestParams {
     request: {

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

@@ -29,10 +29,9 @@ export declare function transactionToBase64String<T extends Transaction>(transac
 export declare function base64StringToTransaction<T extends Transaction>(transactionBytes: string): T;
 /**
  * @param transaction - a base64 encoded string of proto.TransactionBody.encode().finish()
- * @param nodeAccountId - an optional `AccountId` to set the node account ID for the transaction
  * @returns `string`
  * */
-export declare function transactionToTransactionBody<T extends Transaction>(transaction: T, nodeAccountId?: AccountId | null): proto.ITransactionBody;
+export declare function transactionToTransactionBody<T extends Transaction>(transaction: T): any;
 export declare function transactionBodyToBase64String(transactionBody: proto.ITransactionBody): string;
 /**
  * @param transactionList - a proto.TransactionList object

package/dist/lib/shared/utils.js

@@ -54,13 +54,12 @@ export function base64StringToTransaction(transactionBytes) {
 }
 /**
  * @param transaction - a base64 encoded string of proto.TransactionBody.encode().finish()
- * @param nodeAccountId - an optional `AccountId` to set the node account ID for the transaction
  * @returns `string`
  * */
-export function transactionToTransactionBody(transaction, nodeAccountId = null) {
+export function transactionToTransactionBody(transaction) {
     // This is a private function, though provides the capabilities to construct a proto.TransactionBody
     //@ts-ignore
-    return transaction._makeTransactionBody(nodeAccountId);
+    return transaction._makeTransactionBody(null);
 }
 export function transactionBodyToBase64String(transactionBody) {
     return Uint8ArrayToBase64String(proto.TransactionBody.encode(transactionBody).finish());

package/dist/reown/adapter.d.ts

@@ -0,0 +1,37 @@
+import { type ChainNamespace } from '@reown/appkit-common';
+import { AdapterBlueprint } from '@reown/appkit/adapters';
+type UniversalProvider = Parameters<AdapterBlueprint['setUniversalProvider']>[0];
+export declare class HederaAdapter extends AdapterBlueprint {
+    constructor(params: AdapterBlueprint.Params);
+    setUniversalProvider(universalProvider: UniversalProvider): void;
+    connect(params: AdapterBlueprint.ConnectParams): Promise<AdapterBlueprint.ConnectResult>;
+    disconnect(): Promise<void>;
+    getAccounts({ namespace, }: AdapterBlueprint.GetAccountsParams & {
+        namespace: ChainNamespace;
+    }): Promise<AdapterBlueprint.GetAccountsResult>;
+    syncConnectors(): Promise<void>;
+    getBalance(params: AdapterBlueprint.GetBalanceParams): Promise<AdapterBlueprint.GetBalanceResult>;
+    signMessage(params: AdapterBlueprint.SignMessageParams): Promise<AdapterBlueprint.SignMessageResult>;
+    estimateGas(params: AdapterBlueprint.EstimateGasTransactionArgs): Promise<AdapterBlueprint.EstimateGasTransactionResult>;
+    sendTransaction(params: AdapterBlueprint.SendTransactionParams): Promise<AdapterBlueprint.SendTransactionResult>;
+    writeContract(params: AdapterBlueprint.WriteContractParams): Promise<AdapterBlueprint.WriteContractResult>;
+    getEnsAddress(params: AdapterBlueprint.GetEnsAddressParams): Promise<AdapterBlueprint.GetEnsAddressResult>;
+    parseUnits(params: AdapterBlueprint.ParseUnitsParams): AdapterBlueprint.ParseUnitsResult;
+    formatUnits(params: AdapterBlueprint.FormatUnitsParams): AdapterBlueprint.FormatUnitsResult;
+    getCapabilities(params: AdapterBlueprint.GetCapabilitiesParams): Promise<unknown>;
+    getProfile(): Promise<AdapterBlueprint.GetProfileResult>;
+    grantPermissions(): Promise<unknown>;
+    revokePermissions(): Promise<`0x${string}`>;
+    syncConnection(params: AdapterBlueprint.SyncConnectionParams): Promise<{
+        id: string;
+        type: "WALLET_CONNECT";
+        chainId: string | number;
+        provider: UniversalProvider;
+        address: string;
+    }>;
+    switchNetwork(params: AdapterBlueprint.SwitchNetworkParams): Promise<void>;
+    protected getWalletConnectConnector(): ReturnType<AdapterBlueprint['getWalletConnectConnector']>;
+    getWalletConnectProvider(): UniversalProvider;
+    walletGetAssets(_params: AdapterBlueprint.WalletGetAssetsParams): Promise<AdapterBlueprint.WalletGetAssetsResponse>;
+}
+export {};

package/dist/reown/adapter.js

@@ -0,0 +1,255 @@
+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 } from './utils';
+import { getAccountInfo } from '..';
+export class HederaAdapter extends AdapterBlueprint {
+    constructor(params) {
+        var _a, _b;
+        if (params.namespace !== hederaNamespace && params.namespace !== 'eip155') {
+            throw new Error('Namespace must be "hedera" or "eip155"');
+        }
+        if (params.namespace == 'eip155') {
+            if ((_a = params.networks) === null || _a === void 0 ? void 0 : _a.some((n) => n.chainNamespace != 'eip155')) {
+                throw new Error('Invalid networks for eip155 namespace');
+            }
+        }
+        else {
+            if ((_b = params.networks) === null || _b === void 0 ? void 0 : _b.some((n) => n.chainNamespace != hederaNamespace)) {
+                throw new Error('Invalid networks for hedera namespace');
+            }
+        }
+        super(Object.assign({}, params));
+    }
+    setUniversalProvider(universalProvider) {
+        this.addConnector(new HederaConnector({
+            provider: universalProvider,
+            caipNetworks: this.getCaipNetworks() || [],
+            namespace: this.namespace,
+        }));
+    }
+    async connect(params) {
+        return Promise.resolve({
+            id: 'WALLET_CONNECT',
+            type: 'WALLET_CONNECT',
+            chainId: Number(params.chainId),
+            provider: this.provider,
+            address: '',
+        });
+    }
+    async disconnect() {
+        try {
+            const connector = this.getWalletConnectConnector();
+            await connector.disconnect();
+        }
+        catch (error) {
+            console.warn('UniversalAdapter:disconnect - error', error);
+        }
+    }
+    async getAccounts({ namespace, }) {
+        var _a, _b, _c, _d;
+        const provider = this.provider;
+        const addresses = (((_d = (_c = (_b = (_a = provider === null || provider === void 0 ? void 0 : provider.session) === null || _a === void 0 ? void 0 : _a.namespaces) === null || _b === void 0 ? void 0 : _b[namespace]) === null || _c === void 0 ? void 0 : _c.accounts) === null || _d === void 0 ? void 0 : _d.map((account) => {
+            const [, , address] = account.split(':');
+            return address;
+        }).filter((address, index, self) => self.indexOf(address) === index)) || []);
+        return Promise.resolve({
+            accounts: addresses.map((address) => CoreHelperUtil.createAccount(namespace, address, 'eoa')),
+        });
+    }
+    async syncConnectors() {
+        return Promise.resolve();
+    }
+    async getBalance(params) {
+        const { address, caipNetwork } = params;
+        if (!caipNetwork) {
+            return Promise.resolve({
+                balance: '0',
+                decimals: 0,
+                symbol: '',
+            });
+        }
+        const accountInfo = await getAccountInfo(caipNetwork.testnet ? LedgerId.TESTNET : LedgerId.MAINNET, address);
+        return Promise.resolve({
+            balance: (accountInfo === null || accountInfo === void 0 ? void 0 : accountInfo.balance)
+                ? formatUnits(accountInfo.balance.balance, 8).toString()
+                : '0',
+            decimals: caipNetwork.nativeCurrency.decimals,
+            symbol: caipNetwork.nativeCurrency.symbol,
+        });
+    }
+    async signMessage(params) {
+        const { provider, message, address } = params;
+        if (!provider) {
+            throw new Error('Provider is undefined');
+        }
+        const hederaProvider = provider;
+        let signature = '';
+        if (this.namespace === hederaNamespace) {
+            const response = await hederaProvider.hedera_signMessage({
+                signerAccountId: address,
+                message,
+            });
+            signature = response.signatureMap;
+        }
+        else {
+            signature = await hederaProvider.eth_signMessage(message, address);
+        }
+        return { signature };
+    }
+    async estimateGas(params) {
+        const { provider, caipNetwork, address } = params;
+        if (this.namespace !== 'eip155') {
+            throw new Error('Namespace is not eip155');
+        }
+        if (!provider) {
+            throw new Error('Provider is undefined');
+        }
+        const hederaProvider = provider;
+        const result = await hederaProvider.eth_estimateGas({
+            data: params.data,
+            to: params.to,
+            address: address,
+        }, address, Number(caipNetwork === null || caipNetwork === void 0 ? void 0 : caipNetwork.id));
+        return { gas: result };
+    }
+    async sendTransaction(params) {
+        var _a;
+        if (!params.provider) {
+            throw new Error('Provider is undefined');
+        }
+        const hederaProvider = params.provider;
+        if (this.namespace == 'eip155') {
+            const tx = await hederaProvider.eth_sendTransaction({
+                value: params.value,
+                to: params.to,
+                data: params.data,
+                gas: params.gas,
+                gasPrice: params.gasPrice,
+                address: params.address,
+            }, params.address, Number((_a = params.caipNetwork) === null || _a === void 0 ? void 0 : _a.id));
+            return { hash: tx };
+        }
+        else {
+            throw new Error('Namespace is not eip155');
+        }
+    }
+    async writeContract(params) {
+        if (!params.provider) {
+            throw new Error('Provider is undefined');
+        }
+        if (this.namespace !== 'eip155') {
+            throw new Error('Namespace is not eip155');
+        }
+        const { provider, caipNetwork, caipAddress, abi, tokenAddress, method, args } = params;
+        const browserProvider = new BrowserProvider(provider, Number(caipNetwork === null || caipNetwork === void 0 ? void 0 : caipNetwork.id));
+        const signer = new JsonRpcSigner(browserProvider, caipAddress);
+        const contract = new Contract(tokenAddress, abi, signer);
+        if (!contract || !method) {
+            throw new Error('Contract method is undefined');
+        }
+        const contractMethod = contract[method];
+        if (contractMethod) {
+            const result = await contractMethod(...args);
+            return { hash: result };
+        }
+        else
+            throw new Error('Contract method is undefined');
+    }
+    async getEnsAddress(params) {
+        if (this.namespace !== 'eip155') {
+            throw new Error('Namespace is not eip155');
+        }
+        const { name, caipNetwork } = params;
+        if (caipNetwork) {
+            if (isReownName(name)) {
+                return {
+                    address: (await WcHelpersUtil.resolveReownName(name)) || false,
+                };
+            }
+        }
+        return { address: false };
+    }
+    parseUnits(params) {
+        return parseUnits(params.value, params.decimals);
+    }
+    formatUnits(params) {
+        return formatUnits(params.value, params.decimals);
+    }
+    async getCapabilities(params) {
+        var _a, _b;
+        if (this.namespace !== 'eip155') {
+            throw new Error('Namespace is not eip155');
+        }
+        const provider = ProviderUtil.getProvider('eip155');
+        if (!provider) {
+            throw new Error('Provider is undefined');
+        }
+        const walletCapabilitiesString = (_b = (_a = provider.session) === null || _a === void 0 ? void 0 : _a.sessionProperties) === null || _b === void 0 ? void 0 : _b['capabilities'];
+        if (walletCapabilitiesString) {
+            try {
+                const walletCapabilities = JSON.parse(walletCapabilitiesString);
+                const accountCapabilities = walletCapabilities[params];
+                if (accountCapabilities) {
+                    return accountCapabilities;
+                }
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            }
+            catch (error) {
+                throw new Error('Error parsing wallet capabilities');
+            }
+        }
+        return await provider.request({
+            method: 'wallet_getCapabilities',
+            params: [params],
+        });
+    }
+    // Not supported
+    async getProfile() {
+        return Promise.resolve({
+            profileImage: '',
+            profileName: '',
+        });
+    }
+    // Not supported
+    async grantPermissions() {
+        return Promise.resolve({});
+    }
+    // Not supported
+    async revokePermissions() {
+        return Promise.resolve('0x');
+    }
+    async syncConnection(params) {
+        return Promise.resolve({
+            id: 'WALLET_CONNECT',
+            type: 'WALLET_CONNECT',
+            chainId: params.chainId,
+            provider: this.provider,
+            address: '',
+        });
+    }
+    async switchNetwork(params) {
+        const { caipNetwork } = params;
+        const connector = this.getWalletConnectConnector();
+        connector.provider.setDefaultChain(caipNetwork.caipNetworkId);
+    }
+    getWalletConnectConnector() {
+        const connector = this.connectors.find((c) => c.type == 'WALLET_CONNECT');
+        if (!connector) {
+            throw new Error('WalletConnectConnector not found');
+        }
+        return connector;
+    }
+    getWalletConnectProvider() {
+        const connector = this.connectors.find((c) => c.type === 'WALLET_CONNECT');
+        const provider = connector === null || connector === void 0 ? void 0 : connector.provider;
+        return provider;
+    }
+    async walletGetAssets(_params) {
+        return Promise.resolve({});
+    }
+}

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

@@ -0,0 +1,29 @@
+import type { SessionTypes } from '@walletconnect/types';
+import { CaipNetwork, ChainNamespace } from '@reown/appkit-common';
+import { AdapterBlueprint, type ChainAdapterConnector } from '@reown/appkit/adapters';
+type UniversalProvider = Parameters<AdapterBlueprint['setUniversalProvider']>[0];
+export declare class HederaConnector implements ChainAdapterConnector {
+    readonly id: "walletConnect";
+    readonly name: string;
+    readonly type = "WALLET_CONNECT";
+    readonly imageId: string;
+    readonly chain: ChainNamespace;
+    provider: UniversalProvider;
+    protected caipNetworks: CaipNetwork[];
+    constructor({ provider, caipNetworks, namespace }: HederaConnector.Options);
+    get chains(): CaipNetwork[];
+    connectWalletConnect(): Promise<{
+        clientId: string;
+        session: SessionTypes.Struct;
+    }>;
+    disconnect(): Promise<void>;
+    authenticate(): Promise<boolean>;
+}
+export declare namespace HederaConnector {
+    type Options = {
+        provider: UniversalProvider;
+        caipNetworks: CaipNetwork[];
+        namespace: 'hedera' | 'eip155';
+    };
+}
+export {};

package/dist/reown/connectors/HederaConnector.js

@@ -0,0 +1,35 @@
+import { ConstantsUtil } from '@reown/appkit-common';
+import { PresetsUtil } from '@reown/appkit-utils';
+import { createNamespaces } from '../utils';
+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.caipNetworks = caipNetworks;
+        this.provider = provider;
+        this.chain = namespace;
+    }
+    get chains() {
+        return this.caipNetworks;
+    }
+    async connectWalletConnect() {
+        const isAuthenticated = await this.authenticate();
+        if (!isAuthenticated) {
+            await this.provider.connect({
+                optionalNamespaces: createNamespaces(this.caipNetworks),
+            });
+        }
+        return {
+            clientId: await this.provider.client.core.crypto.getClientId(),
+            session: this.provider.session,
+        };
+    }
+    async disconnect() {
+        await this.provider.disconnect();
+    }
+    async authenticate() {
+        return false;
+    }
+}