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

package/README.md

@@ -13,7 +13,7 @@ read transactions. Hedera implements EVM compatible smart contracts using
 [Hyperledger Besu](https://besu.hyperledger.org/) under the hood.
 
 Ethereum developers and toolsets often expect to interact with Ethereum compatible chains using
-the [Ethereum JSON-RPC](https://ethereum.org/en/developers/docs/apis/json-rpc/). To acheive
+the [Ethereum JSON-RPC](https://ethereum.org/en/developers/docs/apis/json-rpc/). To achieve
 compatibility with this API,
 [Hedera JSON-RPC Providers](https://docs.hedera.com/hedera/core-concepts/smart-contracts/json-rpc-relay#community-hosted-json-rpc-relays)
 operate a software middlelayer that translates Ethereum JSON-RPC compatible API calls into
@@ -26,7 +26,7 @@ transactions to wallets over the WalletConnect network using the JSON-RPC spec d
 Hedera native transactions or use Ethereum JSON-RPC calls sent to a Hedera JSON-RPC Relay
 provider which then communicates with Hedera consensus and mirror nodes.
 
-On a high level, JSON-RPC is a type of API stucture, such as SOAP, gRPC, REST, GraphQL, etc. In
+On a high level, JSON-RPC is a type of API structure, such as SOAP, gRPC, REST, GraphQL, etc. In
 the Hedera ecosystem, there are distinct concepts regarding JSON-RPC APIs to consider:
 
 - Ethereum JSON-RPC spec defines how to interact with Ethereum compatible networks
@@ -34,7 +34,7 @@ the Hedera ecosystem, there are distinct concepts regarding JSON-RPC APIs to con
 - Wallets in the Hedera ecosystem also support a separate specification that defines how to send
   transactions and messages to wallets over the WalletConnect network without relying on a
   Hedera JSON-RPC Relay provider. This is a Hedera specific specification defined for utilizing
-  the WalletConnect network distict from other JSON-RPC specs such as the one defined by the
+  the WalletConnect network distinct from other JSON-RPC specs such as the one defined by the
   Ethereum network.
 
 For more information see:
@@ -64,7 +64,7 @@ reviewing the [Reown docs](https://docs.reown.com/overview).
 1. Add Hedera dependencies to your project:
 
 ```sh
-npm install @hashgraph/hedera-wallet-connect@2.0.0-canary.811af2f.0 @hashgraph/sdk @walletconnect/modal
+npm install @hashgraph/hedera-wallet-connect @hashgraph/sdk @walletconnect/modal
 ```
 
 2. Initialize dApp Connector
@@ -121,7 +121,7 @@ await dAppConnector.openModal()
 2. Add Hedera dependencies to your project:
 
 ```sh
-npm install @hashgraph/hedera-wallet-connect@2.0.1-canary.24fffa7.0 @hashgraph/sdk @walletconnect/universal-provider
+npm install @hashgraph/hedera-wallet-connect @hashgraph/sdk @walletconnect/universal-provider
 ```
 
 3. Update `createAppKit` with adapters and a universal provider for Hedera. Note the
@@ -154,7 +154,7 @@ const hederaEVMAdapter = new HederaAdapter({
 })
 
 const universalProvider = (await HederaProvider.init({
-  projectId: "YOUR_PROJECT_ID"
+  projectId: "YOUR_PROJECT_ID",
   metadata,
 })) as unknown as UniversalProvider, // avoid type mismatch error due to missing of private properties in HederaProvider
 
@@ -211,6 +211,141 @@ createAppKit({
 - [Hedera Wallet Example by Hgraph](https://github.com/hgraph-io/hedera-wallet)
 - <em>[Add an example, demo, or tool here](https://github.com/hashgraph/hedera-wallet-connect/pulls)</em>
 
+# Multi-Signature Transactions
+
+Multi-signature (multi-sig) workflows allow multiple parties to sign a single transaction before it's executed on the Hedera network. This is commonly used for:
+
+- Treasury operations requiring approval from multiple parties
+- Escrow services
+- Joint accounts
+- Backend co-signing for additional security
+
+## Using `hedera_signTransaction` for Multi-Sig Workflows
+
+The `hedera_signTransaction` method allows you to collect a signature from a wallet without immediately executing the transaction. This signature can then be combined with additional signatures (such as from a backend service) before final execution.
+
+### Example: Frontend Wallet Signature + Backend Co-Signature
+
+This example demonstrates a common pattern where a user signs a transaction in their wallet, and then a backend service adds its signature before executing the transaction.
+
+#### Step 1: Create and Sign Transaction on Frontend
+
+```typescript
+import { DAppConnector, HederaJsonRpcMethod } from '@hashgraph/hedera-wallet-connect'
+import { TransferTransaction, Hbar, AccountId } from '@hashgraph/sdk'
+
+// Initialize your DAppConnector (see Getting Started section)
+const dAppConnector = new DAppConnector(/* ... */)
+
+// Create a transaction
+const transaction = new TransferTransaction()
+  .addHbarTransfer(userAccountId, new Hbar(-10))
+  .addHbarTransfer(recipientAccountId, new Hbar(10))
+  .setTransactionMemo('Multi-sig transfer')
+
+// Request signature from wallet (does NOT execute)
+const signer = dAppConnector.getSigner(userAccountId)
+const signedTransaction = await signer.signTransaction(transaction)
+
+// Convert signed transaction to bytes for transmission to backend
+const signedTransactionBytes = signedTransaction.toBytes()
+
+// Send to backend
+const response = await fetch('/api/execute-transaction', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    signedTransaction: Buffer.from(signedTransactionBytes).toString('base64'),
+  }),
+})
+
+const result = await response.json()
+console.log('Transaction executed:', result.transactionId)
+```
+
+#### Step 2: Add Backend Signature and Execute
+
+On your backend, use the `addSignatureToTransaction` utility to add your server's signature:
+
+```typescript
+import { Transaction, PrivateKey, Client } from '@hashgraph/sdk'
+import { addSignatureToTransaction } from '@hashgraph/hedera-wallet-connect'
+
+// Backend API endpoint
+app.post('/api/execute-transaction', async (req, res) => {
+  try {
+    // Reconstruct transaction from bytes
+    const signedTransactionBytes = Buffer.from(req.body.signedTransaction, 'base64')
+    const signedTransaction = Transaction.fromBytes(signedTransactionBytes)
+
+    // Load your backend private key (store securely!)
+    const backendPrivateKey = PrivateKey.fromStringED25519(process.env.BACKEND_PRIVATE_KEY)
+
+    // Add backend signature to the transaction
+    const fullySignedTransaction = await addSignatureToTransaction(
+      signedTransaction,
+      backendPrivateKey,
+    )
+
+    // Execute the fully signed transaction
+    const client = Client.forTestnet() // or Client.forMainnet()
+    client.setOperator(backendAccountId, backendPrivateKey)
+
+    const txResponse = await fullySignedTransaction.execute(client)
+    const receipt = await txResponse.getReceipt(client)
+
+    res.json({
+      success: true,
+      transactionId: txResponse.transactionId.toString(),
+      status: receipt.status.toString(),
+    })
+  } catch (error) {
+    console.error('Error executing transaction:', error)
+    res.status(500).json({ error: error.message })
+  }
+})
+```
+
+### Important Notes
+
+1. **Transaction Must Be Frozen**: Before signing, ensure your transaction is frozen.
+
+2. **Signature Order**: Signatures can be added in any order. Hedera validates that all required signatures are present when the transaction is executed.
+
+3. **Security Considerations**:
+   - Never expose backend private keys to the frontend
+   - Validate transaction contents on the backend before adding your signature
+   - Implement proper authentication and authorization
+   - Consider implementing transaction limits and approval workflows
+
+4. **Multiple Signatures**: You can add more than two signatures using the same pattern:
+
+```typescript
+// Add multiple signatures sequentially
+let signedTx = await addSignatureToTransaction(transaction, privateKey1)
+signedTx = await addSignatureToTransaction(signedTx, privateKey2)
+signedTx = await addSignatureToTransaction(signedTx, privateKey3)
+
+// Execute with all signatures
+await signedTx.execute(client)
+```
+
+5. **Threshold Keys**: For accounts with threshold key structures, ensure you collect enough signatures to meet the threshold requirement before execution.
+
+### Alternative: Using `hedera_signAndExecuteTransaction`
+
+If you don't need backend co-signing and want the wallet to execute the transaction immediately:
+
+```typescript
+// This signs AND executes in one call
+const result = await dAppConnector.signAndExecuteTransaction({
+  signerAccountId: `hedera:testnet:${userAccountId}`,
+  transactionList: transactionToBase64String(transaction),
+})
+```
+
+Use `hedera_signTransaction` when you need to collect multiple signatures. Use `hedera_signAndExecuteTransaction` when the wallet's signature alone is sufficient to execute the transaction.
+
 # Hedera Wallets
 
 - [Hashpack](https://hashpack.app/)
@@ -226,12 +361,10 @@ refer to how to send transactions to wallets using the `hedera:(mainnet|testnet)
 While minimal, the main breaking changes are:
 
 - remove WalletConnect v1 modals
-
   - these are very old, though in the spirit of semver, we kept the dependency until this
     library's v2 release
 
 - remove setting node id's within this library for transactions
-
   - initially, a transaction created by the Hedera Javascript SDK needed to have one or more
     consensus node ids set to be able to serialize into bytes, sent over a network, and
     deserialized by the SDK

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hashgraph/hedera-wallet-connect",
-  "version": "2.0.4-canary.f71fa76.0",
+  "version": "2.0.5-canary.09073be.0",
   "description": "A library to facilitate integrating Hedera with WalletConnect",
   "repository": {
     "type": "git",
@@ -29,7 +29,8 @@
   },
   "peerDependencies": {
     "@hashgraph/sdk": "^2.63.0",
-    "@reown/appkit": "^1.7.16",
+    "@reown/appkit": "1.8.10",
+    "@reown/appkit-controllers": "1.8.10",
     "@reown/walletkit": "^1.2.8",
     "@walletconnect/modal": "^2.7.0",
     "ethers": "^6.13.5"
@@ -38,6 +39,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"

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,301 +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) {
-        const transactionBody = transactionToTransactionBody(transaction);
-        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);
-        const bodyBytes = base64StringToUint8Array(transactionBodyBase64);
-        const bytes = proto.Transaction.encode({ bodyBytes, sigMap }).finish();
-        return Transaction.fromBytes(bytes);
-    }
-    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';
-    }
-}