@hashgraph/hedera-wallet-connect 1.3.7-canary.de9fb58.0 → 1.3.8-canary.09d9623.0

package/dist/{src/lib → lib}/dapp/DAppSigner.d.ts

@@ -6,7 +6,13 @@ export declare class DAppSigner implements Signer {
     readonly topic: string;
     private readonly ledgerId;
     readonly extensionId?: string | undefined;
-    constructor(accountId: AccountId, signClient: ISignClient, topic: string, ledgerId?: LedgerId, extensionId?: string | undefined);
+    private logger;
+    constructor(accountId: AccountId, signClient: ISignClient, topic: string, ledgerId?: LedgerId, extensionId?: string | undefined, logLevel?: 'error' | 'warn' | 'info' | 'debug');
+    /**
+     * Sets the logging level for the DAppSigner
+     * @param level - The logging level to set
+     */
+    setLogLevel(level: 'error' | 'warn' | 'info' | 'debug'): void;
     private _getHederaClient;
     private get _signerAccountId();
     private _getRandomNodes;
@@ -25,7 +31,9 @@ export declare class DAppSigner implements Signer {
     getAccountInfo(): Promise<AccountInfo>;
     getAccountRecords(): Promise<TransactionRecord[]>;
     getMetadata(): CoreTypes.Metadata;
-    sign(data: Uint8Array[], signOptions?: Record<string, any>): Promise<SignerSignature[]>;
+    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>;
     /**
@@ -39,6 +47,14 @@ export declare class DAppSigner implements Signer {
     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/{src/lib → lib}/dapp/DAppSigner.js

@@ -19,15 +19,26 @@
  */
 import { AccountBalance, AccountId, 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, Uint8ArrayToBase64String, base64StringToSignatureMap, base64StringToUint8Array, ledgerIdToCAIPChainId, queryToBase64String, transactionBodyToBase64String, transactionToBase64String, transactionToTransactionBody, extensionOpen, } from '../shared';
+import { HederaJsonRpcMethod, base64StringToSignatureMap, base64StringToUint8Array, ledgerIdToCAIPChainId, queryToBase64String, transactionBodyToBase64String, transactionToBase64String, transactionToTransactionBody, extensionOpen, Uint8ArrayToBase64String, Uint8ArrayToString, } from '../shared';
+import { DefaultLogger } from '../shared/logger';
 const clients = {};
 export class DAppSigner {
-    constructor(accountId, signClient, topic, ledgerId = LedgerId.MAINNET, extensionId) {
+    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();
@@ -84,22 +95,34 @@ export class DAppSigner {
     getMetadata() {
         return this.signClient.metadata;
     }
-    async sign(data, signOptions) {
-        const { signatureMap } = await this.request({
-            method: HederaJsonRpcMethod.SignMessage,
-            params: {
-                signerAccountId: this._signerAccountId,
-                message: Uint8ArrayToBase64String(data[0]),
-            },
-        });
-        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,
-        });
-        return [signerSignature];
+    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.');
@@ -141,7 +164,10 @@ export class DAppSigner {
     }
     async _tryExecuteTransactionRequest(request) {
         try {
-            const transaction = Transaction.fromBytes(request.toBytes());
+            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: {
@@ -149,9 +175,11 @@ export class DAppSigner {
                     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 };
         }
     }
@@ -178,9 +206,44 @@ export class DAppSigner {
             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 query = Query.fromBytes(request.toBytes());
+            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: {
@@ -188,6 +251,7 @@ export class DAppSigner {
                     query: queryToBase64String(query),
                 },
             });
+            this.logger.debug('Query request completed successfully', result);
             return { result: this._parseQueryResponse(query, result.response) };
         }
         catch (error) {
@@ -195,27 +259,42 @@ export class DAppSigner {
         }
     }
     async call(request) {
-        var _a, _b, _c, _d, _e, _f;
-        const txResult = await this._tryExecuteTransactionRequest(request);
-        if (txResult.result) {
-            return txResult.result;
+        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;
         }
         // TODO: make this error more usable
+        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: (_a = txResult.error) === null || _a === void 0 ? void 0 : _a.name,
-                    message: (_b = txResult.error) === null || _b === void 0 ? void 0 : _b.message,
-                    stack: (_c = txResult.error) === null || _c === void 0 ? void 0 : _c.stack,
+                    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: (_d = queryResult.error) === null || _d === void 0 ? void 0 : _d.name,
-                    message: (_e = queryResult.error) === null || _e === void 0 ? void 0 : _e.message,
-                    stack: (_f = queryResult.error) === null || _f === void 0 ? void 0 : _f.stack,
+                    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/{src/lib → lib}/dapp/index.d.ts

@@ -211,5 +211,9 @@ export declare class DAppConnector {
      * ```
      */
     signTransaction(params: SignTransactionParams): Promise<SignTransactionResult>;
+    private handleSessionEvent;
+    private handleSessionUpdate;
+    private handleSessionDelete;
+    private handlePairingDelete;
 }
 export default DAppConnector;

package/dist/{src/lib → lib}/dapp/index.js

@@ -110,45 +110,10 @@ export class DAppConnector {
                 this.signers = existingSessions.flatMap((session) => this.createSigners(session));
             else
                 this.checkIframeConnect();
-            this.walletConnectClient.on('session_event', (event) => {
-                // Handle session events, such as "chainChanged", "accountsChanged", etc.
-                this.logger.debug('Session event received:', event);
-                this.validateAndRefreshSigners();
-            });
-            this.walletConnectClient.on('session_update', ({ topic, params }) => {
-                // Handle session update
-                const { namespaces } = params;
-                const _session = this.walletConnectClient.session.get(topic);
-                // Overwrite the `namespaces` of the existing session with the incoming one.
-                const updatedSession = Object.assign(Object.assign({}, _session), { namespaces });
-                // Integrate the updated session state into your dapp state.
-                this.logger.info('Session updated:', updatedSession);
-                this.signers = this.signers.filter((signer) => signer.topic !== topic);
-                this.signers.push(...this.createSigners(updatedSession));
-            });
-            this.walletConnectClient.on('session_delete', (pairing) => {
-                this.logger.info('Session deleted:', pairing);
-                this.signers = this.signers.filter((signer) => signer.topic !== pairing.topic);
-                // Session was deleted -> reset the dapp state, clean up from user session, etc.
-                try {
-                    this.disconnect(pairing.topic);
-                }
-                catch (e) {
-                    this.logger.error('Error disconnecting session:', e);
-                }
-                this.logger.info('Session deleted by wallet');
-            });
-            this.walletConnectClient.core.pairing.events.on('pairing_delete', (pairing) => {
-                this.logger.info('Pairing deleted:', pairing);
-                this.signers = this.signers.filter((signer) => signer.topic !== pairing.topic);
-                try {
-                    this.disconnect(pairing.topic);
-                }
-                catch (e) {
-                    this.logger.error('Error disconnecting pairing:', e);
-                }
-                this.logger.info('Pairing deleted by wallet');
-            });
+            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));
+            this.walletConnectClient.core.pairing.events.on('pairing_delete', this.handlePairingDelete.bind(this));
         }
         catch (e) {
             this.logger.error('Error initializing DAppConnector:', e);
@@ -344,7 +309,7 @@ export class DAppConnector {
         const allNamespaceAccounts = accountAndLedgerFromSession(session);
         return allNamespaceAccounts.map(({ account, network }) => {
             var _a;
-            return new DAppSigner(account, this.walletConnectClient, session.topic, network, (_a = session.sessionProperties) === null || _a === void 0 ? void 0 : _a.extensionId);
+            return new DAppSigner(account, this.walletConnectClient, session.topic, network, (_a = session.sessionProperties) === null || _a === void 0 ? void 0 : _a.extensionId, this.logger instanceof DefaultLogger ? this.logger.getLogLevel() : 'debug');
         });
     }
     async onSessionConnected(session) {
@@ -542,5 +507,39 @@ export class DAppConnector {
             params,
         });
     }
+    handleSessionEvent(args) {
+        this.logger.debug('Session event received:', args);
+        this.validateAndRefreshSigners();
+    }
+    handleSessionUpdate({ topic, params, }) {
+        const { namespaces } = params;
+        const _session = this.walletConnectClient.session.get(topic);
+        const updatedSession = Object.assign(Object.assign({}, _session), { namespaces });
+        this.logger.info('Session updated:', updatedSession);
+        this.signers = this.signers.filter((signer) => signer.topic !== topic);
+        this.signers.push(...this.createSigners(updatedSession));
+    }
+    handleSessionDelete(event) {
+        this.logger.info('Session deleted:', event);
+        this.signers = this.signers.filter((signer) => signer.topic !== event.topic);
+        try {
+            this.disconnect(event.topic);
+        }
+        catch (e) {
+            this.logger.error('Error disconnecting session:', e);
+        }
+        this.logger.info('Session deleted by wallet');
+    }
+    handlePairingDelete(event) {
+        this.logger.info('Pairing deleted:', event);
+        this.signers = this.signers.filter((signer) => signer.topic !== event.topic);
+        try {
+            this.disconnect(event.topic);
+        }
+        catch (e) {
+            this.logger.error('Error disconnecting pairing:', e);
+        }
+        this.logger.info('Pairing deleted by wallet');
+    }
 }
 export default DAppConnector;

package/dist/{src/lib → lib}/shared/logger.d.ts

@@ -8,6 +8,7 @@ export declare class DefaultLogger implements ILogger {
     private logLevel;
     constructor(logLevel?: 'error' | 'warn' | 'info' | 'debug');
     setLogLevel(level: 'error' | 'warn' | 'info' | 'debug'): void;
+    getLogLevel(): 'error' | 'warn' | 'info' | 'debug';
     error(message: string, ...args: any[]): void;
     warn(message: string, ...args: any[]): void;
     info(message: string, ...args: any[]): void;

package/dist/{src/lib → lib}/shared/logger.js

@@ -6,6 +6,9 @@ export class DefaultLogger {
     setLogLevel(level) {
         this.logLevel = level;
     }
+    getLogLevel() {
+        return this.logLevel;
+    }
     error(message, ...args) {
         if (['error', 'warn', 'info', 'debug'].includes(this.logLevel)) {
             console.error(`[ERROR] ${message}`, ...args);

package/dist/{src/lib → lib}/shared/utils.d.ts

@@ -49,8 +49,8 @@ export declare function base64StringToTransaction<T extends Transaction>(transac
  * @param transaction - a base64 encoded string of proto.TransactionBody.encode().finish()
  * @returns `string`
  * */
-export declare function transactionToTransactionBody<T extends Transaction>(transaction: T, nodeAccountId: AccountId): Uint8Array | null | undefined;
-export declare function transactionBodyToBase64String(transactionBody: Uint8Array): string;
+export declare function transactionToTransactionBody<T extends Transaction>(transaction: T, nodeAccountId: AccountId): any;
+export declare function transactionBodyToBase64String(transactionBody: proto.ITransactionBody): string;
 /**
  * @param transactionList - a proto.TransactionList object
  * @returns `string`
@@ -85,6 +85,12 @@ export declare function base64StringToSignatureMap(base64string: string): proto.
  * @returns Base64-encoded string representation of the input `Uint8Array`
  */
 export declare function Uint8ArrayToBase64String(binary: Uint8Array): string;
+/**
+ * Encodes the binary data represented by the `Uint8Array` to a UTF-8 string.
+ * @param binary - The `Uint8Array` containing binary data to be converted
+ * @returns UTF-8 string representation of the input `Uint8Array`
+ */
+export declare function Uint8ArrayToString(binary: Uint8Array): string;
 /**
  * Converts a Base64-encoded string to a `Uint8Array`.
  * @param base64string - Base64-encoded string to be converted

package/dist/{src/lib → lib}/shared/utils.js

@@ -86,10 +86,10 @@ export function base64StringToTransaction(transactionBytes) {
 export function transactionToTransactionBody(transaction, nodeAccountId) {
     // This is a private function, though provides the capabilities to construct a proto.TransactionBody
     //@ts-ignore
-    return transaction._signedTransactions.current.bodyBytes;
+    return transaction._makeTransactionBody(nodeAccountId);
 }
 export function transactionBodyToBase64String(transactionBody) {
-    return Uint8ArrayToBase64String(transactionBody);
+    return Uint8ArrayToBase64String(proto.TransactionBody.encode(transactionBody).finish());
 }
 /**
  * @param transactionList - a proto.TransactionList object
@@ -139,6 +139,14 @@ export function base64StringToSignatureMap(base64string) {
 export function Uint8ArrayToBase64String(binary) {
     return Buffer.from(binary).toString('base64');
 }
+/**
+ * Encodes the binary data represented by the `Uint8Array` to a UTF-8 string.
+ * @param binary - The `Uint8Array` containing binary data to be converted
+ * @returns UTF-8 string representation of the input `Uint8Array`
+ */
+export function Uint8ArrayToString(binary) {
+    return Buffer.from(binary).toString('utf-8');
+}
 /**
  * Converts a Base64-encoded string to a `Uint8Array`.
  * @param base64string - Base64-encoded string to be converted

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@hashgraph/hedera-wallet-connect",
-  "version": "1.3.7-canary.de9fb58.0",
+  "version": "1.3.8-canary.09d9623.0",
   "description": "A library to facilitate integrating Hedera with WalletConnect",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/hashgraph/hedera-wallet-connect.git"
   },
-  "main": "./dist/src/index.js",
-  "types": "./dist/src/index.d.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "author": "Hgraph <support@hgraph.io>",
   "keywords": [
     "hedera",
@@ -55,6 +55,7 @@
     "dev:ts-demo": "rimraf dist && npm run build && concurrently --raw \"npm run watch\" \"node scripts/demos/typescript/dev.mjs\"",
     "dev:react-demo": "rimraf dist && npm run build && concurrently --raw \"npm run watch\" \"node scripts/demos/react/dev.mjs\"",
     "test": "jest",
+    "test:watch": "jest --watch",
     "test:connect": "jest --testMatch '**/DAppConnector.test.ts' --verbose",
     "test:signer": "jest --testMatch '**/DAppSigner.test.ts' --verbose",
     "prepublishOnly": "rm -Rf dist && npm run build",

package/dist/test/_helpers.d.ts

@@ -1,38 +0,0 @@
-import { AccountId, Query, Transaction, TransactionId } from '@hashgraph/sdk';
-export declare const projectId = "ce06497abf4102004138a10edd29c921";
-export declare const walletMetadata: {
-    name: string;
-    url: string;
-    description: string;
-    icons: string[];
-};
-export declare const dAppMetadata: {
-    name: string;
-    url: string;
-    description: string;
-    icons: string[];
-};
-export declare const requestId = 1;
-export declare const requestTopic = "test-topic";
-export declare const defaultAccountNumber = 12345;
-export declare const defaultNodeId = 3;
-export declare const testUserAccountId: AccountId;
-export declare const testNodeAccountId: AccountId;
-/** Fixed to a specific timestamp */
-export declare const testTransactionId: TransactionId;
-type TransactionOptions = {
-    setNodeAccountIds?: boolean;
-    setTransactionId?: boolean;
-    freeze?: boolean;
-    operatorAccountId?: number;
-};
-export declare function prepareTestTransaction<T extends Transaction = Transaction>(transaction: T, options?: TransactionOptions): T;
-type QueryOptions = {
-    setNodeAccountIds?: boolean;
-};
-export declare function prepareTestQuery<Q extends Query<OutputT>, OutputT>(query: Q, options?: QueryOptions): Q;
-export declare const testPrivateKeyECDSA = "3030020100300706052b8104000a042204203ce31ffad30d6db47c315bbea08232aad2266d8800a12aa3d8a812486e782759";
-export declare const testPrivateKeyED25519 = "302e020100300506032b657004220420133eefea772add1f995c96bccf42b08b76daf67665f0c4c5ae308fae9275c142";
-export declare function useJsonFixture(filename: string): any;
-export declare function writeJsonFixture(filename: string, data: any): void;
-export {};

package/dist/test/_helpers.js

@@ -1,95 +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 fs from 'fs';
-import path from 'path';
-import { AccountId, TransactionId } from '@hashgraph/sdk';
-export const projectId = 'ce06497abf4102004138a10edd29c921';
-export const walletMetadata = {
-    name: 'Wallet Test',
-    url: 'https://dapp.hedera.app',
-    description: 'Hedera Hashgraph Wallet Example.',
-    icons: [
-        'https://cdn-assets-cloud.frontify.com/s3/frontify-cloud-files-us/eyJwYXRoIjoiZnJvbnRpZnlcL2FjY291bnRzXC8xNFwvMTQzMTI3XC9wcm9qZWN0c1wvMTgwMjE1XC9hc3NldHNcL2M3XC8zNDU0ODY3XC85ZjM1NDliYmE5MGQ2NDA0OGU0NzlhZTNiMzkyYzY4Yy0xNTY2NTkxOTQ4LmpwZyJ9:frontify:v_zJvQTCjtNploUvnSpk8S5NJB4R5eei6f7ERL2KSeQ?width=800',
-    ],
-};
-export const dAppMetadata = {
-    name: 'dApp Test',
-    url: 'https://dapp.hedera.app',
-    description: 'Hedera Hashgraph dApp Example.',
-    icons: [
-        'https://cdn-assets-cloud.frontify.com/s3/frontify-cloud-files-us/eyJwYXRoIjoiZnJvbnRpZnlcL2FjY291bnRzXC8xNFwvMTQzMTI3XC9wcm9qZWN0c1wvMTgwMjE1XC9hc3NldHNcL2M3XC8zNDU0ODY3XC85ZjM1NDliYmE5MGQ2NDA0OGU0NzlhZTNiMzkyYzY4Yy0xNTY2NTkxOTQ4LmpwZyJ9:frontify:v_zJvQTCjtNploUvnSpk8S5NJB4R5eei6f7ERL2KSeQ?width=800',
-    ],
-};
-export const requestId = 1;
-export const requestTopic = 'test-topic';
-export const defaultAccountNumber = 12345;
-export const defaultNodeId = 3;
-export const testUserAccountId = new AccountId(defaultAccountNumber);
-export const testNodeAccountId = new AccountId(defaultNodeId);
-/** Fixed to a specific timestamp */
-export const testTransactionId = TransactionId.fromString(`0.0.${defaultAccountNumber}@1691705630.325343432`);
-export function prepareTestTransaction(transaction, options) {
-    const selectedOptions = Object.assign({ 
-        // defaults
-        freeze: false, setNodeAccountIds: true, setTransactionId: true, operatorAccountId: defaultAccountNumber }, options);
-    if (selectedOptions.setNodeAccountIds) {
-        transaction.setNodeAccountIds([testNodeAccountId]);
-    }
-    if (selectedOptions.setTransactionId) {
-        let transactionId = testTransactionId;
-        if (selectedOptions.operatorAccountId &&
-            selectedOptions.operatorAccountId !== defaultAccountNumber) {
-            transactionId = TransactionId.generate(new AccountId(selectedOptions.operatorAccountId));
-        }
-        transaction.setTransactionId(transactionId);
-    }
-    if (selectedOptions.freeze) {
-        transaction.freeze();
-    }
-    return transaction;
-}
-export function prepareTestQuery(query, options) {
-    const selectedOptions = Object.assign({ 
-        // defaults
-        setNodeAccountIds: true }, options);
-    if (selectedOptions.setNodeAccountIds) {
-        query.setNodeAccountIds([testNodeAccountId]);
-    }
-    return query;
-}
-// from PrivateKey.generateECDSA().toStringDer()
-export const testPrivateKeyECDSA = '3030020100300706052b8104000a042204203ce31ffad30d6db47c315bbea08232aad2266d8800a12aa3d8a812486e782759';
-// from PrivateKey.generateED25519().toStringDer()
-export const testPrivateKeyED25519 = '302e020100300506032b657004220420133eefea772add1f995c96bccf42b08b76daf67665f0c4c5ae308fae9275c142';
-/** JSON fixture helpers */
-const FIXTURES_PATH = 'test/_fixtures';
-const filenameWithJsonExtension = (filename) => {
-    const file = /\.json$/.test(filename) ? filename : filename + '.json';
-    return path.join(FIXTURES_PATH, file);
-};
-export function useJsonFixture(filename) {
-    const filepath = filenameWithJsonExtension(filename);
-    const data = fs.readFileSync(filepath).toString();
-    return JSON.parse(data);
-}
-export function writeJsonFixture(filename, data) {
-    const filepath = filenameWithJsonExtension(filename);
-    fs.writeFileSync(filepath, JSON.stringify(data, null, 2));
-}

package/dist/test/dapp/DAppConnector.test.d.ts

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