@hashgraph/hedera-wallet-connect 2.0.4 → 2.0.5-canary.09073be.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hashgraph/hedera-wallet-connect",
-  "version": "2.0.4",
+  "version": "2.0.5-canary.09073be.0",
   "description": "A library to facilitate integrating Hedera with WalletConnect",
   "repository": {
     "type": "git",

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,21 +0,0 @@
-/*
- *
- * Hedera Wallet Connect
- *
- * Copyright (C) 2023 Hedera Hashgraph, LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-export * from './lib';
-export * from './reown';

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

@@ -1,60 +0,0 @@
-import { Signer, AccountBalance, AccountId, AccountInfo, Executable, Key, LedgerId, SignerSignature, Transaction, TransactionRecord } from '@hashgraph/sdk';
-import type { CoreTypes, ISignClient } from '@walletconnect/types';
-import { LogLevel } from '../shared/logger';
-export declare class DAppSigner implements Signer {
-    private readonly accountId;
-    private readonly signClient;
-    readonly topic: string;
-    private readonly ledgerId;
-    readonly extensionId?: string | undefined;
-    private logger;
-    constructor(accountId: AccountId, signClient: ISignClient, topic: string, ledgerId?: LedgerId, extensionId?: string | undefined, logLevel?: LogLevel);
-    /**
-     * Sets the logging level for the DAppSigner
-     * @param level - The logging level to set
-     */
-    setLogLevel(level: LogLevel): void;
-    private _getHederaClient;
-    private get _signerAccountId();
-    request<T>(request: {
-        method: string;
-        params: any;
-    }): Promise<T>;
-    getAccountId(): AccountId;
-    getAccountKey(): Key;
-    getLedgerId(): LedgerId;
-    getNetwork(): {
-        [key: string]: string | AccountId;
-    };
-    getMirrorNetwork(): string[];
-    getAccountBalance(): Promise<AccountBalance>;
-    getAccountInfo(): Promise<AccountInfo>;
-    getAccountRecords(): Promise<TransactionRecord[]>;
-    getMetadata(): CoreTypes.Metadata;
-    sign(data: Uint8Array[], signOptions?: {
-        encoding?: 'utf-8' | 'base64';
-    }): Promise<SignerSignature[]>;
-    checkTransaction<T extends Transaction>(transaction: T): Promise<T>;
-    populateTransaction<T extends Transaction>(transaction: T): Promise<T>;
-    /**
-     * Prepares a transaction object for signing using a single node account id.
-     * If the transaction object does not already have a node account id,
-     * generate a random node account id using the Hedera SDK client
-     *
-     * @param transaction - Any instance of a class that extends `Transaction`
-     * @returns transaction - `Transaction` object with signature
-     */
-    signTransaction<T extends Transaction>(transaction: T): Promise<T>;
-    private _tryExecuteTransactionRequest;
-    private _parseQueryResponse;
-    /**
-     * Executes a free receipt query without signing a transaction.
-     * Enables the DApp to fetch the receipt of a transaction without making a new request
-     * to the wallet.
-     * @param request - The query to execute
-     * @returns The result of the query
-     */
-    private executeReceiptQueryFromRequest;
-    private _tryExecuteQueryRequest;
-    call<RequestT, ResponseT, OutputT>(request: Executable<RequestT, ResponseT, OutputT>): Promise<OutputT>;
-}

package/dist/lib/dapp/DAppSigner.js

@@ -1,344 +0,0 @@
-/*
- *
- * Hedera Wallet Connect
- *
- * Copyright (C) 2023 Hedera Hashgraph, LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-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 { DefaultLogger } from '../shared/logger';
-import { SessionNotFoundError } from './SessionNotFoundError';
-const clients = {};
-export class DAppSigner {
-    constructor(accountId, signClient, topic, ledgerId = LedgerId.MAINNET, extensionId, logLevel = 'debug') {
-        this.accountId = accountId;
-        this.signClient = signClient;
-        this.topic = topic;
-        this.ledgerId = ledgerId;
-        this.extensionId = extensionId;
-        this.logger = new DefaultLogger(logLevel);
-    }
-    /**
-     * Sets the logging level for the DAppSigner
-     * @param level - The logging level to set
-     */
-    setLogLevel(level) {
-        if (this.logger instanceof DefaultLogger) {
-            this.logger.setLogLevel(level);
-        }
-    }
-    _getHederaClient() {
-        const ledgerIdString = this.ledgerId.toString();
-        if (!clients[ledgerIdString]) {
-            clients[ledgerIdString] = Client.forName(ledgerIdString);
-        }
-        return clients[ledgerIdString];
-    }
-    get _signerAccountId() {
-        return `${ledgerIdToCAIPChainId(this.ledgerId)}:${this.accountId.toString()}`;
-    }
-    request(request) {
-        var _a, _b;
-        // Avoid a wallet call if the session is no longer valid
-        if (!((_b = (_a = this === null || this === void 0 ? void 0 : this.signClient) === null || _a === void 0 ? void 0 : _a.session) === null || _b === void 0 ? void 0 : _b.get(this.topic))) {
-            this.logger.error('Session no longer exists, signer will be removed. Please reconnect to the wallet.');
-            // Notify DAppConnector to remove this signer
-            this.signClient.emit({
-                topic: this.topic,
-                event: {
-                    name: 'session_delete',
-                    data: { topic: this.topic },
-                },
-                chainId: ledgerIdToCAIPChainId(this.ledgerId),
-            });
-            throw new SessionNotFoundError('Session no longer exists. Please reconnect to the wallet.');
-        }
-        if (this.extensionId)
-            extensionOpen(this.extensionId);
-        return this.signClient.request({
-            topic: this.topic,
-            request,
-            chainId: ledgerIdToCAIPChainId(this.ledgerId),
-        });
-    }
-    getAccountId() {
-        return this.accountId;
-    }
-    getAccountKey() {
-        throw new Error('Method not implemented.');
-    }
-    getLedgerId() {
-        return this.ledgerId;
-    }
-    getNetwork() {
-        return this._getHederaClient().network;
-    }
-    getMirrorNetwork() {
-        return this._getHederaClient().mirrorNetwork;
-    }
-    getAccountBalance() {
-        return this.call(new AccountBalanceQuery().setAccountId(this.accountId));
-    }
-    getAccountInfo() {
-        return this.call(new AccountInfoQuery().setAccountId(this.accountId));
-    }
-    getAccountRecords() {
-        return this.call(new AccountRecordsQuery().setAccountId(this.accountId));
-    }
-    getMetadata() {
-        return this.signClient.metadata;
-    }
-    async sign(data, signOptions = {
-        encoding: 'utf-8',
-    }) {
-        try {
-            const messageToSign = signOptions.encoding === 'base64'
-                ? Uint8ArrayToBase64String(data[0])
-                : Uint8ArrayToString(data[0]);
-            const { signatureMap } = await this.request({
-                method: HederaJsonRpcMethod.SignMessage,
-                params: {
-                    signerAccountId: this._signerAccountId,
-                    message: messageToSign,
-                },
-            });
-            const sigmap = base64StringToSignatureMap(signatureMap);
-            const signerSignature = new SignerSignature({
-                accountId: this.getAccountId(),
-                publicKey: PublicKey.fromBytes(sigmap.sigPair[0].pubKeyPrefix),
-                signature: sigmap.sigPair[0].ed25519 ||
-                    sigmap.sigPair[0].ECDSASecp256k1,
-            });
-            this.logger.debug('Data signed successfully');
-            return [signerSignature];
-        }
-        catch (error) {
-            this.logger.error('Error signing data:', error);
-            throw error;
-        }
-    }
-    async checkTransaction(transaction) {
-        throw new Error('Method not implemented.');
-    }
-    async populateTransaction(transaction) {
-        return transaction.setTransactionId(TransactionId.generate(this.getAccountId()));
-    }
-    /**
-     * Prepares a transaction object for signing using a single node account id.
-     * If the transaction object does not already have a node account id,
-     * generate a random node account id using the Hedera SDK client
-     *
-     * @param transaction - Any instance of a class that extends `Transaction`
-     * @returns transaction - `Transaction` object with signature
-     */
-    async signTransaction(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);
-        const { signatureMap } = await this.request({
-            method: HederaJsonRpcMethod.SignTransaction,
-            params: {
-                signerAccountId: this._signerAccountId,
-                transactionBody: transactionBodyBase64,
-            },
-        });
-        const sigMap = base64StringToSignatureMap(signatureMap);
-        // 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 {
-            const requestToBytes = request.toBytes();
-            this.logger.debug('Creating transaction from bytes', requestToBytes, request);
-            const transaction = Transaction.fromBytes(requestToBytes);
-            this.logger.debug('Executing transaction request', transaction);
-            const result = await this.request({
-                method: HederaJsonRpcMethod.SignAndExecuteTransaction,
-                params: {
-                    signerAccountId: this._signerAccountId,
-                    transactionList: transactionToBase64String(transaction),
-                },
-            });
-            this.logger.debug('Transaction request completed successfully');
-            return { result: TransactionResponse.fromJSON(result) };
-        }
-        catch (error) {
-            this.logger.error('Error executing transaction request:', error);
-            return { error };
-        }
-    }
-    async _parseQueryResponse(query, base64EncodedQueryResponse) {
-        if (query instanceof AccountRecordsQuery) {
-            const base64EncodedQueryResponseSplit = base64EncodedQueryResponse.split(',');
-            const data = base64EncodedQueryResponseSplit.map((o) => base64StringToUint8Array(o));
-            return data.map((o) => TransactionRecord.fromBytes(o));
-        }
-        const data = base64StringToUint8Array(base64EncodedQueryResponse);
-        if (query instanceof AccountBalanceQuery) {
-            return AccountBalance.fromBytes(data);
-        }
-        else if (query instanceof AccountInfoQuery) {
-            return AccountInfo.fromBytes(data);
-        }
-        else if (query instanceof TransactionReceiptQuery) {
-            return TransactionReceipt.fromBytes(data);
-        }
-        else if (query instanceof TransactionRecordQuery) {
-            return TransactionRecord.fromBytes(data);
-        }
-        else {
-            throw new Error('Unsupported query type');
-        }
-    }
-    /**
-     * Executes a free receipt query without signing a transaction.
-     * Enables the DApp to fetch the receipt of a transaction without making a new request
-     * to the wallet.
-     * @param request - The query to execute
-     * @returns The result of the query
-     */
-    async executeReceiptQueryFromRequest(request) {
-        try {
-            const isMainnet = this.ledgerId === LedgerId.MAINNET;
-            const client = isMainnet ? Client.forMainnet() : Client.forTestnet();
-            const receipt = TransactionReceiptQuery.fromBytes(request.toBytes());
-            const result = await receipt.execute(client);
-            return { result };
-        }
-        catch (error) {
-            return { error };
-        }
-    }
-    async _tryExecuteQueryRequest(request) {
-        try {
-            const isReceiptQuery = request instanceof TransactionReceiptQuery;
-            if (isReceiptQuery) {
-                this.logger.debug('Attempting to execute free receipt query', request);
-                const result = await this.executeReceiptQueryFromRequest(request);
-                if (!(result === null || result === void 0 ? void 0 : result.error)) {
-                    return { result: result.result };
-                }
-                this.logger.error('Error executing free receipt query. Sending to wallet.', result.error);
-            }
-            /**
-             * Note, should we be converting these to specific query types?
-             * Left alone to avoid changing the API for other requests.
-             */
-            const query = isReceiptQuery
-                ? TransactionReceiptQuery.fromBytes(request.toBytes())
-                : Query.fromBytes(request.toBytes());
-            this.logger.debug('Executing query request', query, queryToBase64String(query), isReceiptQuery);
-            const result = await this.request({
-                method: HederaJsonRpcMethod.SignAndExecuteQuery,
-                params: {
-                    signerAccountId: this._signerAccountId,
-                    query: queryToBase64String(query),
-                },
-            });
-            this.logger.debug('Query request completed successfully', result);
-            return { result: this._parseQueryResponse(query, result.response) };
-        }
-        catch (error) {
-            this.logger.error('Error executing query request:', error);
-            return { error };
-        }
-    }
-    async call(request) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-        const isReceiptQuery = request instanceof TransactionReceiptQuery;
-        let txResult = undefined;
-        // a receipt query is a free query and we should not execute a transaction.
-        if (!isReceiptQuery) {
-            txResult = await this._tryExecuteTransactionRequest(request);
-            if (txResult.result) {
-                return txResult.result;
-            }
-        }
-        const queryResult = await this._tryExecuteQueryRequest(request);
-        if (queryResult.result) {
-            return queryResult.result;
-        }
-        if (isReceiptQuery) {
-            throw new Error('Error executing receipt query: \n' +
-                JSON.stringify({
-                    queryError: {
-                        name: (_a = queryResult.error) === null || _a === void 0 ? void 0 : _a.name,
-                        message: (_b = queryResult.error) === null || _b === void 0 ? void 0 : _b.message,
-                        stack: (_c = queryResult.error) === null || _c === void 0 ? void 0 : _c.stack,
-                    },
-                }));
-        }
-        throw new Error('Error executing transaction or query: \n' +
-            JSON.stringify({
-                txError: {
-                    name: (_d = txResult === null || txResult === void 0 ? void 0 : txResult.error) === null || _d === void 0 ? void 0 : _d.name,
-                    message: (_e = txResult === null || txResult === void 0 ? void 0 : txResult.error) === null || _e === void 0 ? void 0 : _e.message,
-                    stack: (_f = txResult === null || txResult === void 0 ? void 0 : txResult.error) === null || _f === void 0 ? void 0 : _f.stack,
-                },
-                queryError: {
-                    name: (_g = queryResult.error) === null || _g === void 0 ? void 0 : _g.name,
-                    message: (_h = queryResult.error) === null || _h === void 0 ? void 0 : _h.message,
-                    stack: (_j = queryResult.error) === null || _j === void 0 ? void 0 : _j.stack,
-                },
-            }, null, 2));
-    }
-}

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

@@ -1,3 +0,0 @@
-export declare class SessionNotFoundError extends Error {
-    constructor(message: string);
-}

package/dist/lib/dapp/SessionNotFoundError.js

@@ -1,6 +0,0 @@
-export class SessionNotFoundError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'SessionNotFoundError';
-    }
-}

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

@@ -1,216 +0,0 @@
-import { AccountId, LedgerId, Transaction } from '@hashgraph/sdk';
-import { 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';
-export * from './DAppSigner';
-export { SessionNotFoundError } from './SessionNotFoundError';
-type BaseLogger = 'error' | 'warn' | 'info' | 'debug' | 'trace' | 'fatal';
-export declare class DAppConnector {
-    private logger;
-    dAppMetadata: SignClientTypes.Metadata;
-    network: LedgerId;
-    projectId: string;
-    supportedMethods: string[];
-    supportedEvents: string[];
-    supportedChains: string[];
-    extensions: ExtensionData[];
-    onSessionIframeCreated: ((session: SessionTypes.Struct) => void) | null;
-    walletConnectClient: SignClient | undefined;
-    walletConnectModal: WalletConnectModal;
-    signers: DAppSigner[];
-    isInitializing: boolean;
-    /**
-     * Initializes the DAppConnector instance.
-     * @param metadata - SignClientTypes.Metadata object for the DApp metadata.
-     * @param network - LedgerId representing the network (default: LedgerId.TESTNET).
-     * @param projectId - Project ID for the WalletConnect client.
-     * @param methods - Array of supported methods for the DApp (optional).
-     * @param events - Array of supported events for the DApp (optional).
-     * @param chains - Array of supported chains for the DApp (optional).
-     * @param logLevel - Logging level for the DAppConnector (optional).
-     */
-    constructor(metadata: SignClientTypes.Metadata, network: LedgerId, projectId: string, methods?: string[], events?: string[], chains?: string[], logLevel?: LogLevel);
-    /**
-     * Sets the logging level for the DAppConnector
-     * @param level - The logging level to set
-     */
-    setLogLevel(level: LogLevel): void;
-    /**
-     * Initializes the DAppConnector instance.
-     * @param logger - `BaseLogger` for logging purposes (optional).
-     */
-    init({ logger }?: {
-        logger?: BaseLogger;
-    }): Promise<void>;
-    /**
-     * Retrieves a DAppSigner for the specified Hedera Account ID.
-     *
-     * @param {AccountId} accountId - The Hedera Account ID to find the associated signer.
-     * @returns {DAppSigner} - The signer object of type {@link DAppSigner} corresponding to the provided account ID.
-     * @throws {Error} - If no signer is found for the provided account ID.
-     */
-    getSigner(accountId: AccountId): DAppSigner;
-    /**
-     * Initiates the WalletConnect connection flow using a QR code.
-     * @param pairingTopic - The pairing topic for the connection (optional).
-     * @param throwErrorOnReject - Whether to show an error when the user rejects the pairing (default: false).
-     * @returns {Promise<SessionTypes.Struct>} - A Promise that resolves when the connection process is complete.
-     */
-    openModal(pairingTopic?: string, throwErrorOnReject?: boolean): Promise<SessionTypes.Struct>;
-    /**
-     * Initiates the WallecConnect connection flow using URI.
-     * @param pairingTopic - The pairing topic for the connection (optional).
-     * @param extensionId - The id for the extension used to connect (optional).
-     * @returns A Promise that resolves when the connection process is complete.
-     */
-    connect(launchCallback: (uri: string) => void, pairingTopic?: string, extensionId?: string): Promise<SessionTypes.Struct>;
-    /**
-     * Initiates the WallecConnect connection flow sending a message to the extension.
-     * @param extensionId - The id for the extension used to connect.
-     * @param pairingTopic - The pairing topic for the connection (optional).
-     * @returns A Promise that resolves when the connection process is complete.
-     */
-    connectExtension(extensionId: string, pairingTopic?: string): Promise<SessionTypes.Struct>;
-    /**
-     * Validates the session by checking if the session exists and is valid.
-     * Also ensures the signer exists for the session.
-     * @param topic - The topic of the session to validate.
-     * @returns {boolean} - True if the session exists and has a valid signer, false otherwise.
-     */
-    private validateSession;
-    /**
-     * Validates the session and refreshes the signers by removing the invalid ones.
-     */
-    private validateAndRefreshSigners;
-    /**
-     *  Initiates the WallecConnect connection if the wallet in iframe mode is detected.
-     */
-    private checkIframeConnect;
-    private abortableConnect;
-    /**
-     * Disconnects the current session associated with the specified topic.
-     * @param topic - The topic of the session to disconnect.
-     * @returns A Promise that resolves when the session is disconnected.
-     */
-    disconnect(topic: string): Promise<boolean>;
-    /**
-     * Disconnects all active sessions and pairings.
-     *
-     * Throws error when WalletConnect is not initialized or there are no active sessions/pairings.
-     * @returns A Promise that resolves when all active sessions and pairings are disconnected.
-     */
-    disconnectAll(): Promise<void>;
-    private createSigners;
-    private onSessionConnected;
-    private connectURI;
-    private request;
-    /**
-     * Retrieves the node addresses associated with the current Hedera network.
-     *
-     * When there is no active session or an error occurs during the request.
-     * @returns Promise\<{@link GetNodeAddressesResult}\>
-     */
-    getNodeAddresses(): Promise<GetNodeAddressesResult>;
-    /**
-     * Executes a transaction on the Hedera network.
-     *
-     * @param {ExecuteTransactionParams} params - The parameters of type {@link ExecuteTransactionParams | `ExecuteTransactionParams`} required for the transaction execution.
-     * @param {string[]} params.signedTransaction - Array of Base64-encoded `Transaction`'s
-     * @returns Promise\<{@link ExecuteTransactionResult}\>
-     * @example
-     * Use helper `transactionToBase64String` to encode `Transaction` to Base64 string
-     * ```ts
-     * const params = {
-     *  signedTransaction: [transactionToBase64String(transaction)]
-     * }
-     *
-     * const result = await dAppConnector.executeTransaction(params)
-     * ```
-     */
-    executeTransaction(params: ExecuteTransactionParams): Promise<ExecuteTransactionResult>;
-    /**
-     * Signs a provided `message` with provided `signerAccountId`.
-     *
-     * @param {SignMessageParams} params - The parameters of type {@link SignMessageParams | `SignMessageParams`} required for signing message.
-     * @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 {string} params.message - a plain UTF-8 string
-     * @returns Promise\<{@link SignMessageResult}\>
-     * @example
-     * ```ts
-     * const params = {
-     *  signerAccountId: 'hedera:testnet:0.0.12345',
-     *  message: 'Hello World!'
-     * }
-     *
-     * const result = await dAppConnector.signMessage(params)
-     * ```
-     */
-    signMessage(params: SignMessageParams): Promise<SignMessageResult>;
-    /**
-     * Signs and send `Query` on the Hedera network.
-     *
-     * @param {SignAndExecuteQueryParams} params - The parameters of type {@link SignAndExecuteQueryParams | `SignAndExecuteQueryParams`} required for the Query execution.
-     * @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 {string} params.query - `Query` object represented as Base64 string
-     * @returns Promise\<{@link SignAndExecuteQueryResult}\>
-     * @example
-     * Use helper `queryToBase64String` to encode `Query` to Base64 string
-     * ```ts
-     * const params = {
-     *  signerAccountId: '0.0.12345',
-     *  query: queryToBase64String(query),
-     * }
-     *
-     * const result = await dAppConnector.signAndExecuteQuery(params)
-     * ```
-     */
-    signAndExecuteQuery(params: SignAndExecuteQueryParams): Promise<SignAndExecuteQueryResult>;
-    /**
-     * Signs and executes Transactions on the Hedera network.
-     *
-     * @param {SignAndExecuteTransactionParams} params - The parameters of type {@link SignAndExecuteTransactionParams | `SignAndExecuteTransactionParams`} required for `Transaction` signing and execution.
-     * @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 {string[]} params.transaction - Array of Base64-encoded `Transaction`'s
-     * @returns Promise\<{@link SignAndExecuteTransactionResult}\>
-     * @example
-     * Use helper `transactionToBase64String` to encode `Transaction` to Base64 string
-     * ```ts
-     * const params = {
-     *  signerAccountId: '0.0.12345'
-     *  transaction: [transactionToBase64String(transaction)]
-     * }
-     *
-     * const result = await dAppConnector.signAndExecuteTransaction(params)
-     * ```
-     */
-    signAndExecuteTransaction(params: SignAndExecuteTransactionParams): Promise<SignAndExecuteTransactionResult>;
-    /**
-     * Signs and executes Transactions on the Hedera network.
-     *
-     * @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.
-     * @returns Promise\<{@link SignTransactionResult}\>
-     * @example
-     * ```ts
-     *
-     * const params = {
-     *  signerAccountId: '0.0.12345',
-     *  transactionBody
-     * }
-     *
-     * const result = await dAppConnector.signTransaction(params)
-     * ```
-     */
-    signTransaction(params: SignTransactionParams): Promise<Transaction | SignTransactionResult>;
-    private handleSessionEvent;
-    private handleSessionUpdate;
-    private handleSessionDelete;
-    private handlePairingDelete;
-}
-export default DAppConnector;