@hashgraphonline/hashinal-wc 1.0.86 → 1.0.88

package/README.md

@@ -18,6 +18,10 @@ This SDK provides a simple interface for interacting with the Hedera Hashgraph u
 - Dissociate tokens from accounts
 - Update account properties
 - Approve token allowances
+- Get transaction details by transaction ID or timestamp from the mirror node
+- Get account NFTs with optional filtering by token ID
+- Validate NFT ownership by serial number and token ID
+- Make read-only calls to smart contracts on the mirror node
 
 ## Installation
 
@@ -518,6 +522,109 @@ const tokens = await sdk.getAccountTokens(accountId);
 console.log('Account tokens:', tokens);
 ```
 
+### `getTransaction(transactionId: string)`
+
+Retrieves transaction details by transaction ID from the mirror node.
+
+UMD Example:
+
+```javascript
+const transactionId = "0.0.123456@1234567890.000000000";
+const transaction = await window.HashinalsWalletConnectSDK.getTransaction(transactionId);
+console.log(transaction);
+```
+
+ESM Example:
+
+```javascript
+const transaction = await sdk.getTransaction(transactionId);
+```
+
+### `getTransactionByTimestamp(timestamp: string)`
+
+Retrieves transaction details by consensus timestamp from the mirror node.
+
+UMD Example:
+
+```javascript
+const timestamp = "1234567890.000000000";
+const transaction = await window.HashinalsWalletConnectSDK.getTransactionByTimestamp(timestamp);
+console.log(transaction);
+```
+
+ESM Example:
+
+```javascript
+const transaction = await sdk.getTransactionByTimestamp(timestamp);
+```
+
+### `getAccountNFTs(accountId: string, tokenId?: string)`
+
+Retrieves all NFTs owned by an account, with optional filtering by token ID.
+
+UMD Example:
+
+```javascript
+const accountId = "0.0.123456";
+const nfts = await window.HashinalsWalletConnectSDK.getAccountNFTs(accountId);
+console.log(nfts);
+
+// With token filter
+const tokenId = "0.0.789012";
+const filteredNfts = await window.HashinalsWalletConnectSDK.getAccountNFTs(accountId, tokenId);
+```
+
+ESM Example:
+
+```javascript
+const nfts = await sdk.getAccountNFTs(accountId);
+const filteredNfts = await sdk.getAccountNFTs(accountId, tokenId);
+```
+
+### `validateNFTOwnership(serialNumber: string, accountId: string, tokenId: string)`
+
+Validates if an account owns a specific NFT by serial number and token ID.
+
+UMD Example:
+
+```javascript
+const serialNumber = "1";
+const accountId = "0.0.123456";
+const tokenId = "0.0.789012";
+const nft = await window.HashinalsWalletConnectSDK.validateNFTOwnership(serialNumber, accountId, tokenId);
+console.log(nft ? "Account owns this NFT" : "Account does not own this NFT");
+```
+
+ESM Example:
+
+```javascript
+const nft = await sdk.validateNFTOwnership(serialNumber, accountId, tokenId);
+```
+
+### `readSmartContract(data: string, fromAccount: AccountId, contractId: ContractId, estimate?: boolean, value?: number)`
+
+Makes a read-only call to a smart contract on the mirror node.
+
+UMD Example:
+
+```javascript
+const data = "0x..."; // Contract call data
+const fromAccount = window.HashgraphSDK.AccountId.fromString("0.0.123456");
+const contractId = window.HashgraphSDK.ContractId.fromString("0.0.789012");
+const result = await window.HashinalsWalletConnectSDK.readSmartContract(data, fromAccount, contractId);
+console.log(result);
+```
+
+ESM Example:
+
+```javascript
+import { AccountId, ContractId } from '@hashgraph/sdk';
+
+const fromAccount = AccountId.fromString("0.0.123456");
+const contractId = ContractId.fromString("0.0.789012");
+const result = await sdk.readSmartContract(data, fromAccount, contractId);
+```
+
 ## Versions and Topic IDs
 
 Version 1.0.58 and onward correlate with the NPM Package version.
@@ -532,6 +639,8 @@ Version 1.0.58 and onward correlate with the NPM Package version.
 | v1.0.71 | 0.0.7337015 | UMD  |
 | v1.0.79 | 0.0.7473819 | UMD  |
 | v1.0.82 | 0.0.7522981 | UMD  |
+| v1.0.86 | 0.0.7770334 | UMD  |
+| v1.0.88 | 0.0.7797532 | UMD  |
 
 ## Contributing
 

package/dist/es/hashinal-wc.es.js

@@ -1810,13 +1810,15 @@ var Result = /* @__PURE__ */ ((Result2) => {
   return Result2;
 })(Result || {});
 class HashinalsWalletConnectSDK {
-  get dAppConnector() {
-    return HashinalsWalletConnectSDK.dAppConnectorInstance;
-  }
   constructor(logger, network) {
+    this.extensionCheckInterval = null;
+    this.hasCalledExtensionCallback = false;
     this.logger = logger || new DefaultLogger();
     this.network = network || LedgerId.MAINNET;
   }
+  get dAppConnector() {
+    return HashinalsWalletConnectSDK.dAppConnectorInstance;
+  }
   static getInstance(logger, network) {
     let instance = HashinalsWalletConnectSDK == null ? void 0 : HashinalsWalletConnectSDK.instance;
     if (!instance) {
@@ -2235,12 +2237,13 @@ class HashinalsWalletConnectSDK {
       return false;
     }
   }
-  async initAccount(PROJECT_ID, APP_METADATA) {
+  async initAccount(PROJECT_ID, APP_METADATA, networkOverride, onSessionIframeCreated = () => {
+  }) {
     const { accountId: savedAccountId, network: savedNetwork } = this.loadConnectionInfo();
     if (savedAccountId && savedNetwork) {
       try {
         const network = savedNetwork === "mainnet" ? LedgerId.MAINNET : LedgerId.TESTNET;
-        await this.init(PROJECT_ID, APP_METADATA, network);
+        await this.init(PROJECT_ID, APP_METADATA, network, onSessionIframeCreated);
         const balance = await this.getAccountBalance();
         return {
           accountId: savedAccountId,
@@ -2251,9 +2254,70 @@ class HashinalsWalletConnectSDK {
         this.saveConnectionInfo(void 0, void 0);
         return null;
       }
+    } else if (networkOverride) {
+      try {
+        this.logger.info("initializing normally through override.", networkOverride);
+        await this.init(PROJECT_ID, APP_METADATA, networkOverride, onSessionIframeCreated);
+        this.logger.info("initialized", networkOverride);
+        await this.connectViaDappBrowser();
+        this.logger.info("connected via dapp browser");
+      } catch (error) {
+        this.logger.error("Failed to fallback connect:", error);
+        this.saveConnectionInfo(void 0, void 0);
+        return null;
+      }
     }
     return null;
   }
+  subscribeToExtensions(callback) {
+    if (this.extensionCheckInterval) {
+      clearInterval(this.extensionCheckInterval);
+    }
+    this.hasCalledExtensionCallback = false;
+    this.extensionCheckInterval = setInterval(() => {
+      var _a;
+      const extensions = ((_a = this.dAppConnector) == null ? void 0 : _a.extensions) || [];
+      const availableExtension = extensions.find((ext) => ext.availableInIframe);
+      if (availableExtension && !this.hasCalledExtensionCallback) {
+        this.hasCalledExtensionCallback = true;
+        callback(availableExtension);
+        if (this.extensionCheckInterval) {
+          clearInterval(this.extensionCheckInterval);
+          this.extensionCheckInterval = null;
+        }
+      }
+    }, 1e3);
+    return () => {
+      if (this.extensionCheckInterval) {
+        clearInterval(this.extensionCheckInterval);
+        this.extensionCheckInterval = null;
+      }
+      this.hasCalledExtensionCallback = false;
+    };
+  }
+  async connectViaDappBrowser() {
+    const extensions = this.dAppConnector.extensions || [];
+    const extension = extensions.find((ext) => {
+      this.logger.info("Checking extension", ext);
+      return ext.availableInIframe;
+    });
+    this.logger.info("extensions are", extensions, extension);
+    if (extension) {
+      await this.connectToExtension(extension);
+    } else {
+      this.subscribeToExtensions(async (newExtension) => {
+        await this.connectToExtension(newExtension);
+      });
+    }
+  }
+  async connectToExtension(extension) {
+    this.logger.info("found extension, connecting to iframe.", extension);
+    const session = await this.dAppConnector.connectExtension(extension.id);
+    const onSessionIframeCreated = this.dAppConnector.onSessionIframeCreated;
+    if (onSessionIframeCreated) {
+      onSessionIframeCreated(session);
+    }
+  }
   ensureInitialized() {
     if (!this.dAppConnector) {
       throw new Error("SDK not initialized. Call init() first.");
@@ -2371,6 +2435,126 @@ class HashinalsWalletConnectSDK {
       throw error;
     }
   }
+  async getTransaction(transactionId) {
+    try {
+      const networkPrefix = this.getNetworkPrefix();
+      const url = `https://${networkPrefix}.mirrornode.hedera.com/api/v1/transactions/${transactionId}`;
+      this.logger.debug("Fetching transaction", url);
+      const request = await fetchWithRetry()(url);
+      if (!request.ok) {
+        throw new Error(`Failed to fetch transaction: ${request.status}`);
+      }
+      return await request.json();
+    } catch (e) {
+      this.logger.error("Failed to get transaction", e);
+      return null;
+    }
+  }
+  async getTransactionByTimestamp(timestamp) {
+    var _a;
+    try {
+      const networkPrefix = this.getNetworkPrefix();
+      const url = `https://${networkPrefix}.mirrornode.hedera.com/api/v1/transactions?timestamp=${timestamp}`;
+      this.logger.debug("Fetching transaction by timestamp", url);
+      const request = await fetchWithRetry()(url);
+      if (!request.ok) {
+        throw new Error(
+          `Failed to fetch transaction by timestamp: ${request.status}`
+        );
+      }
+      const response = await request.json();
+      const transaction = (_a = response == null ? void 0 : response.transactions) == null ? void 0 : _a[0];
+      if (transaction) {
+        return await this.getTransaction(transaction.transaction_id);
+      }
+      return null;
+    } catch (e) {
+      this.logger.error("Failed to get transaction by timestamp", e);
+      return null;
+    }
+  }
+  async getAccountNFTs(accountId, tokenId) {
+    var _a, _b, _c;
+    try {
+      const networkPrefix = this.getNetworkPrefix();
+      const tokenQuery = tokenId ? `&token.id=${tokenId}` : "";
+      const url = `https://${networkPrefix}.mirrornode.hedera.com/api/v1/accounts/${accountId}/nfts?limit=200${tokenQuery}`;
+      const request = await fetchWithRetry()(url);
+      if (!request.ok) {
+        throw new Error(`Failed to fetch NFTs for account: ${request.status}`);
+      }
+      const response = await request.json();
+      let nextLink = ((_a = response == null ? void 0 : response.links) == null ? void 0 : _a.next) || null;
+      let nfts = response.nfts;
+      while (nextLink) {
+        try {
+          const nextRequest = await fetchWithRetry()(
+            `https://${networkPrefix}.mirrornode.hedera.com${nextLink}`
+          );
+          if (!nextRequest.ok) {
+            throw new Error(
+              `Failed to fetch next page of NFTs: ${nextRequest.status}`
+            );
+          }
+          const nextResponse = await nextRequest.json();
+          nfts = [...nfts, ...(nextResponse == null ? void 0 : nextResponse.nfts) || []];
+          nextLink = ((_b = nextResponse == null ? void 0 : nextResponse.links) == null ? void 0 : _b.next) && nextLink !== ((_c = nextResponse == null ? void 0 : nextResponse.links) == null ? void 0 : _c.next) ? nextResponse.links.next : null;
+        } catch (e) {
+          this.logger.error("Failed to fetch next page of NFTs", e);
+          break;
+        }
+      }
+      return nfts.map((nft) => {
+        try {
+          nft.token_uri = Buffer$1.from(nft.metadata, "base64").toString("ascii");
+        } catch (e) {
+          this.logger.error("Failed to decode NFT metadata", e);
+        }
+        return nft;
+      });
+    } catch (e) {
+      this.logger.error("Failed to get account NFTs", e);
+      return [];
+    }
+  }
+  async validateNFTOwnership(serialNumber, accountId, tokenId) {
+    const userNFTs = await this.getAccountNFTs(accountId, tokenId);
+    return userNFTs.find(
+      (nft) => nft.token_id === tokenId && nft.serial_number.toString() === serialNumber
+    ) || null;
+  }
+  async readSmartContract(data, fromAccount, contractId, estimate = true, value = 0) {
+    try {
+      const networkPrefix = this.getNetworkPrefix();
+      const body = {
+        block: "latest",
+        data,
+        estimate,
+        from: fromAccount.toSolidityAddress(),
+        to: contractId.toSolidityAddress(),
+        value
+      };
+      if (!estimate) {
+        body.gas = 3e5;
+        body.gasPrice = 1e8;
+      }
+      const url = `https://${networkPrefix}.mirrornode.hedera.com/api/v1/contracts/call`;
+      const response = await fetchWithRetry()(url, {
+        method: "POST",
+        body: JSON.stringify(body),
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to make contract call: ${response.status}`);
+      }
+      return await response.json();
+    } catch (e) {
+      this.logger.error("Failed to make contract call", e);
+      return null;
+    }
+  }
 }
 export {
   HashgraphSDK,