@hashgraphonline/standards-sdk 0.0.157-canary.2 → 0.0.157-canary.4

package/dist/es/standards-sdk.es39.js

@@ -1,586 +1,605 @@
-import { proto } from "@hashgraph/proto";
-import { Buffer } from "buffer";
-import { Hbar, Long, HbarUnit } from "@hashgraph/sdk";
-import { ethers } from "ethers";
-import { HTSParser } from "./standards-sdk.es48.js";
-import { HCSParser } from "./standards-sdk.es49.js";
-import { FileParser } from "./standards-sdk.es50.js";
-import { CryptoParser } from "./standards-sdk.es51.js";
-import { SCSParser } from "./standards-sdk.es52.js";
-import { UtilParser } from "./standards-sdk.es53.js";
-class TransactionParser {
+import { PrivateKey } from "@hashgraph/sdk";
+var KeyType = /* @__PURE__ */ ((KeyType2) => {
+  KeyType2["ED25519"] = "ed25519";
+  KeyType2["ECDSA"] = "ecdsa";
+  KeyType2["UNKNOWN"] = "unknown";
+  return KeyType2;
+})(KeyType || {});
+const _KeyTypeDetector = class _KeyTypeDetector {
   /**
-   * Parse a base64 encoded transaction body and return structured data
-   * @param transactionBodyBase64 - The base64 encoded transaction body
-   * @returns The parsed transaction
+   * Detects private key type from various input formats without throwing errors
+   *
+   * This detector is designed for private keys only. It uses various heuristics to determine
+   * the key type for ambiguous 32-byte keys, including byte patterns and statistical analysis.
+   *
+   * For ambiguous cases (where confidence is 'uncertain'), if you have the associated account ID,
+   * you can use the Hedera mirror node to confirm the key type.
+   *
+   * @param keyInput - The key to detect, can be a string (hex, base64, PEM), Buffer, or Uint8Array
+   * @returns KeyInfo object containing the detected key type and metadata
+   *
+   * @example
+   * // Detect from hex string
+   * const info1 = KeyTypeDetector.detect('0x7f96cea0c0d9d5bfb3ab8a42cf0cea44d57f62f2e068f8e5a3251914a9252b04');
+   *
+   * // Detect from DER-encoded string
+   * const info2 = KeyTypeDetector.detect(privateKey.toStringDer());
+   *
+   * // Detect from PEM format
+   * const info3 = KeyTypeDetector.detect(`-----BEGIN PRIVATE KEY-----
+   * MC4CAQAwBQYDK2VwBCIEIGRchBsQGQduAAGBQ7GAkKCKkmQ3EGCARwHsHiRqTNR9
+   * -----END PRIVATE KEY-----`);
    */
-  static parseTransactionBody(transactionBodyBase64) {
+  static detect(keyInput) {
     try {
-      const buffer = ethers.decodeBase64(transactionBodyBase64);
-      const txBody = proto.SchedulableTransactionBody.decode(buffer);
-      const transactionType = this.getTransactionType(txBody);
-      const result = {
-        type: transactionType,
-        humanReadableType: this.getHumanReadableType(transactionType),
-        transfers: [],
-        tokenTransfers: [],
-        raw: txBody
-      };
-      if (txBody.memo) {
-        result.memo = txBody.memo;
-      }
-      if (txBody.transactionFee) {
-        const hbarAmount = Hbar.fromTinybars(
-          Long.fromValue(txBody.transactionFee)
-        );
-        result.transactionFee = hbarAmount.toString(HbarUnit.Hbar);
-      }
-      if (txBody.cryptoTransfer) {
-        CryptoParser.parseCryptoTransfers(txBody.cryptoTransfer, result);
-      }
-      if (txBody.cryptoDelete) {
-        result.cryptoDelete = CryptoParser.parseCryptoDelete(
-          txBody.cryptoDelete
-        );
-      }
-      if (txBody.cryptoCreateAccount) {
-        result.cryptoCreateAccount = CryptoParser.parseCryptoCreateAccount(
-          txBody.cryptoCreateAccount
-        );
-      }
-      if (txBody.cryptoUpdateAccount) {
-        result.cryptoUpdateAccount = CryptoParser.parseCryptoUpdateAccount(
-          txBody.cryptoUpdateAccount
-        );
-      }
-      if (txBody.cryptoApproveAllowance) {
-        result.cryptoApproveAllowance = CryptoParser.parseCryptoApproveAllowance(
-          txBody.cryptoApproveAllowance
-        );
-      }
-      if (txBody.cryptoDeleteAllowance) {
-        result.cryptoDeleteAllowance = CryptoParser.parseCryptoDeleteAllowance(
-          txBody.cryptoDeleteAllowance
-        );
-      }
-      if (txBody.contractCall) {
-        result.contractCall = SCSParser.parseContractCall(txBody.contractCall);
-      }
-      if (txBody.contractCreateInstance) {
-        result.contractCreate = SCSParser.parseContractCreate(
-          txBody.contractCreateInstance
-        );
-      }
-      if (txBody.contractUpdateInstance) {
-        result.contractUpdate = SCSParser.parseContractUpdate(
-          txBody.contractUpdateInstance
-        );
-      }
-      if (txBody.contractDeleteInstance) {
-        result.contractDelete = SCSParser.parseContractDelete(
-          txBody.contractDeleteInstance
-        );
-      }
-      if (txBody.tokenCreation) {
-        result.tokenCreation = HTSParser.parseTokenCreate(txBody.tokenCreation);
-      }
-      if (txBody.tokenMint) {
-        result.tokenMint = HTSParser.parseTokenMint(txBody.tokenMint);
-      }
-      if (txBody.tokenBurn) {
-        result.tokenBurn = HTSParser.parseTokenBurn(txBody.tokenBurn);
-      }
-      if (txBody.tokenUpdate) {
-        result.tokenUpdate = HTSParser.parseTokenUpdate(txBody.tokenUpdate);
-      }
-      if (txBody.tokenFeeScheduleUpdate) {
-        result.tokenFeeScheduleUpdate = HTSParser.parseTokenFeeScheduleUpdate(
-          txBody.tokenFeeScheduleUpdate
-        );
-      }
-      if (txBody.tokenFreeze) {
-        result.tokenFreeze = HTSParser.parseTokenFreeze(txBody.tokenFreeze);
-      }
-      if (txBody.tokenUnfreeze) {
-        result.tokenUnfreeze = HTSParser.parseTokenUnfreeze(
-          txBody.tokenUnfreeze
-        );
-      }
-      if (txBody.tokenGrantKyc) {
-        result.tokenGrantKyc = HTSParser.parseTokenGrantKyc(
-          txBody.tokenGrantKyc
-        );
-      }
-      if (txBody.tokenRevokeKyc) {
-        result.tokenRevokeKyc = HTSParser.parseTokenRevokeKyc(
-          txBody.tokenRevokeKyc
-        );
-      }
-      if (txBody.tokenPause) {
-        result.tokenPause = HTSParser.parseTokenPause(txBody.tokenPause);
-      }
-      if (txBody.tokenUnpause) {
-        result.tokenUnpause = HTSParser.parseTokenUnpause(txBody.tokenUnpause);
-      }
-      if (txBody.tokenWipe) {
-        result.tokenWipeAccount = HTSParser.parseTokenWipeAccount(
-          txBody.tokenWipe
-        );
-      }
-      if (txBody.tokenDeletion) {
-        result.tokenDelete = HTSParser.parseTokenDelete(txBody.tokenDeletion);
-      }
-      if (txBody.tokenAssociate) {
-        result.tokenAssociate = HTSParser.parseTokenAssociate(
-          txBody.tokenAssociate
-        );
-      }
-      if (txBody.tokenDissociate) {
-        result.tokenDissociate = HTSParser.parseTokenDissociate(
-          txBody.tokenDissociate
-        );
-      }
-      if (txBody.consensusCreateTopic) {
-        result.consensusCreateTopic = HCSParser.parseConsensusCreateTopic(
-          txBody.consensusCreateTopic
-        );
-      }
-      if (txBody.consensusSubmitMessage) {
-        result.consensusSubmitMessage = HCSParser.parseConsensusSubmitMessage(
-          txBody.consensusSubmitMessage
-        );
-      }
-      if (txBody.consensusUpdateTopic) {
-        result.consensusUpdateTopic = HCSParser.parseConsensusUpdateTopic(
-          txBody.consensusUpdateTopic
-        );
-      }
-      if (txBody.consensusDeleteTopic) {
-        result.consensusDeleteTopic = HCSParser.parseConsensusDeleteTopic(
-          txBody.consensusDeleteTopic
-        );
-      }
-      if (txBody.fileCreate) {
-        result.fileCreate = FileParser.parseFileCreate(txBody.fileCreate);
-      }
-      if (txBody.fileAppend) {
-        result.fileAppend = FileParser.parseFileAppend(txBody.fileAppend);
-      }
-      if (txBody.fileUpdate) {
-        result.fileUpdate = FileParser.parseFileUpdate(txBody.fileUpdate);
-      }
-      if (txBody.fileDelete) {
-        result.fileDelete = FileParser.parseFileDelete(txBody.fileDelete);
-      }
-      if (txBody.utilPrng) {
-        result.utilPrng = UtilParser.parseUtilPrng(txBody.utilPrng);
+      let keyBytes;
+      let originalFormat = "raw";
+      if (typeof keyInput === "string") {
+        let trimmed = keyInput.trim();
+        if (trimmed.includes("-----BEGIN")) {
+          return this.detectFromPem(trimmed);
+        }
+        if (trimmed.toLowerCase().startsWith("0x")) {
+          trimmed = trimmed.substring(2);
+        }
+        if (this.isValidHex(trimmed)) {
+          keyBytes = this.hexToBytes(trimmed);
+          originalFormat = "hex";
+        } else if (this.isBase64(trimmed)) {
+          keyBytes = Buffer.from(trimmed, "base64");
+          originalFormat = "der";
+        } else {
+          return {
+            type: "unknown",
+            format: "raw",
+            isPrivateKey: false,
+            confidence: "certain"
+          };
+        }
+      } else if (keyInput instanceof Buffer) {
+        keyBytes = new Uint8Array(keyInput);
+      } else {
+        keyBytes = keyInput;
       }
-      return result;
+      return this.detectFromBytes(keyBytes, originalFormat);
     } catch (error) {
-      throw new Error(
-        `Failed to parse transaction body: ${error instanceof Error ? error.message : String(error)}`
-      );
+      return {
+        type: "unknown",
+        format: "raw",
+        isPrivateKey: false,
+        confidence: "certain"
+      };
     }
   }
   /**
-   * Parse details from a complete schedule response
-   * @param scheduleResponse - The schedule response to parse
-   * @returns The parsed transaction
+   * Detect key type from raw bytes
+   *
+   * @param bytes - The raw bytes of the key
+   * @param format - The original format of the key
+   * @returns KeyInfo object with detection results
+   * @private
    */
-  static parseScheduleResponse(scheduleResponse) {
-    if (!scheduleResponse.transaction_body) {
-      throw new Error("Schedule response missing transaction_body");
+  static detectFromBytes(bytes, format) {
+    if (this.hasPrefix(bytes, this.ED25519_PUBLIC_KEY_PREFIX)) {
+      const keyStart = this.ED25519_PUBLIC_KEY_PREFIX.length;
+      return {
+        type: "ed25519",
+        format: "der",
+        isPrivateKey: false,
+        rawBytes: bytes.slice(keyStart),
+        confidence: "certain"
+      };
     }
-    const parsed = this.parseTransactionBody(scheduleResponse.transaction_body);
-    if (scheduleResponse.memo) {
-      parsed.memo = scheduleResponse.memo;
+    if (this.hasPrefix(bytes, this.ED25519_PRIVATE_KEY_PREFIX)) {
+      const keyStart = this.ED25519_PRIVATE_KEY_PREFIX.length;
+      if (bytes.length >= keyStart + 32) {
+        return {
+          type: "ed25519",
+          format: "der",
+          isPrivateKey: true,
+          rawBytes: bytes.slice(keyStart, keyStart + 32),
+          confidence: "certain"
+        };
+      }
     }
-    return parsed;
-  }
-  /**
-   * Determine the transaction type
-   * @param txBody - The transaction body to determine the type of
-   * @returns The type of the transaction
-   */
-  static getTransactionType(txBody) {
-    let transactionType = "unknown";
-    if (txBody.cryptoTransfer) {
-      transactionType = "cryptoTransfer";
-    } else if (txBody.cryptoCreateAccount) {
-      transactionType = "cryptoCreateAccount";
-    } else if (txBody.cryptoUpdateAccount) {
-      transactionType = "cryptoUpdateAccount";
-    } else if (txBody.cryptoApproveAllowance) {
-      transactionType = "cryptoApproveAllowance";
-    } else if (txBody.cryptoDeleteAllowance) {
-      transactionType = "cryptoDeleteAllowance";
-    } else if (txBody.cryptoDelete) {
-      transactionType = "cryptoDelete";
-    } else if (txBody.consensusCreateTopic) {
-      transactionType = "consensusCreateTopic";
-    } else if (txBody.consensusUpdateTopic) {
-      transactionType = "consensusUpdateTopic";
-    } else if (txBody.consensusSubmitMessage) {
-      transactionType = "consensusSubmitMessage";
-    } else if (txBody.consensusDeleteTopic) {
-      transactionType = "consensusDeleteTopic";
-    } else if (txBody.fileCreate) {
-      transactionType = "fileCreate";
-    } else if (txBody.fileAppend) {
-      transactionType = "fileAppend";
-    } else if (txBody.fileUpdate) {
-      transactionType = "fileUpdate";
-    } else if (txBody.fileDelete) {
-      transactionType = "fileDelete";
-    } else if (txBody.contractCall) {
-      transactionType = "contractCall";
-    } else if (txBody.contractCreateInstance) {
-      transactionType = "contractCreate";
-    } else if (txBody.contractUpdateInstance) {
-      transactionType = "contractUpdate";
-    } else if (txBody.contractDeleteInstance) {
-      transactionType = "contractDelete";
-    } else if (txBody.tokenCreation) {
-      transactionType = "tokenCreate";
-    } else if (txBody.tokenUpdate) {
-      transactionType = "tokenUpdate";
-    } else if (txBody.tokenDeletion) {
-      transactionType = "tokenDelete";
-    } else if (txBody.tokenAssociate) {
-      transactionType = "tokenAssociate";
-    } else if (txBody.tokenDissociate) {
-      transactionType = "tokenDissociate";
-    } else if (txBody.tokenMint) {
-      transactionType = "tokenMint";
-    } else if (txBody.tokenBurn) {
-      transactionType = "tokenBurn";
-    } else if (txBody.tokenFeeScheduleUpdate) {
-      transactionType = "tokenFeeScheduleUpdate";
-    } else if (txBody.tokenFreeze) {
-      transactionType = "tokenFreeze";
-    } else if (txBody.tokenUnfreeze) {
-      transactionType = "tokenUnfreeze";
-    } else if (txBody.tokenGrantKyc) {
-      transactionType = "tokenGrantKyc";
-    } else if (txBody.tokenRevokeKyc) {
-      transactionType = "tokenRevokeKyc";
-    } else if (txBody.tokenPause) {
-      transactionType = "tokenPause";
-    } else if (txBody.tokenUnpause) {
-      transactionType = "tokenUnpause";
-    } else if (txBody.tokenWipe) {
-      transactionType = "tokenWipe";
-    } else if (txBody.utilPrng) {
-      transactionType = "utilPrng";
+    if (this.hasPrefix(bytes, this.ECDSA_SECP256K1_PUBLIC_KEY_PREFIX)) {
+      const keyStart = this.ECDSA_SECP256K1_PUBLIC_KEY_PREFIX.length;
+      return {
+        type: "ecdsa",
+        format: "der",
+        isPrivateKey: false,
+        rawBytes: bytes.slice(keyStart),
+        confidence: "certain"
+      };
+    }
+    if (this.hasPrefix(bytes, this.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX_SHORT)) {
+      const keyStart = this.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX_SHORT.length;
+      return {
+        type: "ecdsa",
+        format: "der",
+        isPrivateKey: true,
+        rawBytes: bytes.slice(keyStart),
+        confidence: "certain"
+      };
+    }
+    if (this.hasPrefix(bytes, this.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX)) {
+      const keyStart = this.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX.length;
+      return {
+        type: "ecdsa",
+        format: "der",
+        isPrivateKey: true,
+        rawBytes: bytes.slice(keyStart, keyStart + 32),
+        confidence: "certain"
+      };
+    }
+    if (this.hasPrefix(bytes, this.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX_LONG)) {
+      const keyStart = this.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX_LONG.length;
+      return {
+        type: "ecdsa",
+        format: "der",
+        isPrivateKey: true,
+        rawBytes: bytes.slice(keyStart, keyStart + 32),
+        confidence: "certain"
+      };
+    }
+    if (bytes.length > 36 && this.containsECDSAPrivateKeyPattern(bytes)) {
+      return {
+        type: "ecdsa",
+        format: "der",
+        isPrivateKey: true,
+        rawBytes: this.extractECDSAPrivateKey(bytes),
+        confidence: "certain"
+      };
+    }
+    switch (bytes.length) {
+      case this.ED25519_PUBLIC_KEY_LENGTH:
+        if (format === "hex") {
+          const hexStr = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+          const privateResult = this.tryCreateKey(hexStr);
+          if (privateResult.type !== "unknown") {
+            return privateResult;
+          }
+        }
+        return {
+          type: "unknown",
+          format,
+          isPrivateKey: false,
+          rawBytes: bytes,
+          confidence: "certain"
+        };
+      case this.ED25519_EXPANDED_PRIVATE_KEY_LENGTH:
+        return {
+          type: "ed25519",
+          format,
+          isPrivateKey: true,
+          rawBytes: bytes,
+          confidence: "certain"
+        };
     }
-    return transactionType;
+    return {
+      type: "unknown",
+      format,
+      isPrivateKey: false,
+      rawBytes: bytes,
+      confidence: "certain"
+    };
   }
   /**
-   * Convert technical transaction type to human-readable format
-   * @param type - The technical transaction type
-   * @returns The human-readable transaction type
+   * Detect key type from PEM format
+   *
+   * @param pem - The PEM-encoded key string
+   * @returns KeyInfo object with detection results
+   * @private
    */
-  static getHumanReadableType(type) {
-    const typeMap = {
-      cryptoTransfer: "HBAR Transfer",
-      cryptoCreateAccount: "Create Account",
-      cryptoUpdateAccount: "Update Account",
-      cryptoDeleteAccount: "Delete Account",
-      cryptoApproveAllowance: "Approve Allowance",
-      cryptoDeleteAllowance: "Delete Allowance",
-      cryptoDelete: "Delete Account",
-      consensusCreateTopic: "Create Topic",
-      consensusUpdateTopic: "Update Topic",
-      consensusSubmitMessage: "Submit Message",
-      consensusDeleteTopic: "Delete Topic",
-      fileCreate: "Create File",
-      fileAppend: "Append File",
-      fileUpdate: "Update File",
-      fileDelete: "Delete File",
-      contractCall: "Contract Call",
-      contractCreate: "Create Contract",
-      contractUpdate: "Update Contract",
-      contractDelete: "Delete Contract",
-      ethereumTransaction: "Ethereum Transaction",
-      tokenCreate: "Create Token",
-      tokenUpdate: "Update Token",
-      tokenDelete: "Delete Token",
-      tokenAssociate: "Associate Token",
-      tokenDissociate: "Dissociate Token",
-      tokenMint: "Mint Token",
-      tokenBurn: "Burn Token",
-      tokenFeeScheduleUpdate: "Update Token Fee Schedule",
-      tokenFreeze: "Freeze Token",
-      tokenUnfreeze: "Unfreeze Token",
-      tokenGrantKyc: "Grant KYC",
-      tokenRevokeKyc: "Revoke KYC",
-      tokenPause: "Pause Token",
-      tokenUnpause: "Unpause Token",
-      tokenWipe: "Wipe Token",
-      scheduleCreate: "Create Schedule",
-      scheduleSign: "Sign Schedule",
-      utilPrng: "Generate Random Number",
-      unknown: "Unknown Transaction"
+  static detectFromPem(pem) {
+    const trimmedPem = pem.trim();
+    const isPrivateKey = trimmedPem.includes("PRIVATE KEY");
+    const pemTypes = {
+      EC_PRIVATE: /-----BEGIN EC PRIVATE KEY-----/,
+      EC_PUBLIC: /-----BEGIN EC PUBLIC KEY-----/,
+      PRIVATE: /-----BEGIN PRIVATE KEY-----/,
+      PUBLIC: /-----BEGIN PUBLIC KEY-----/
     };
-    let result;
-    if (typeMap[type]) {
-      result = typeMap[type];
-    } else {
-      result = "Unknown Transaction";
+    let isECKey = false;
+    for (const [type, regex] of Object.entries(pemTypes)) {
+      if (regex.test(trimmedPem) && type.includes("EC")) {
+        isECKey = true;
+        break;
+      }
+    }
+    const base64Match = trimmedPem.match(
+      /-----BEGIN[\s\S]+?-----[\r\n]+([\s\S]+?)[\r\n]+-----END/
+    );
+    if (!base64Match) {
+      return {
+        type: "unknown",
+        format: "pem",
+        isPrivateKey,
+        confidence: "certain"
+      };
+    }
+    const base64Content = base64Match[1].replace(/\s/g, "");
+    try {
+      const derBytes = Buffer.from(base64Content, "base64");
+      const result = this.detectFromBytes(new Uint8Array(derBytes), "der");
+      if (result.type === "unknown" && isECKey) {
+        return {
+          type: "ecdsa",
+          format: "pem",
+          isPrivateKey,
+          rawBytes: derBytes,
+          confidence: "certain"
+        };
+      }
+      return {
+        ...result,
+        format: "pem"
+      };
+    } catch {
+      return {
+        type: "unknown",
+        format: "pem",
+        isPrivateKey,
+        confidence: "certain"
+      };
     }
-    return result;
   }
   /**
-   * Get a human-readable summary of the transaction
-   * @param parsedTx - The parsed transaction
-   * @returns The human-readable summary of the transaction
+   * Try to create a key using Hedera SDK to validate the type
+   *
+   * @param keyInput - The key input string or bytes
+   * @returns KeyInfo object with detection results
+   * @private
    */
-  static getTransactionSummary(parsedTx) {
-    if (parsedTx.type === "cryptoTransfer") {
-      const senders = [];
-      const receivers = [];
-      for (const transfer of parsedTx.transfers) {
-        const originalAmountFloat = parseFloat(transfer.amount);
-        let displayStr = transfer.amount;
-        if (displayStr.startsWith("-")) {
-          displayStr = displayStr.substring(1);
-        }
-        displayStr = displayStr.replace(/\s*ℏ$/, "");
-        if (originalAmountFloat < 0) {
-          senders.push(`${transfer.accountId} (${displayStr} ℏ)`);
-        } else if (originalAmountFloat > 0) {
-          receivers.push(`${transfer.accountId} (${displayStr} ℏ)`);
-        }
-      }
-      if (senders.length > 0 && receivers.length > 0) {
-        return `Transfer of HBAR from ${senders.join(", ")} to ${receivers.join(
-          ", "
-        )}`;
-      } else {
-        return parsedTx.humanReadableType;
-      }
-    } else if (parsedTx.contractCall) {
-      let contractCallSummary = `Contract call to ${parsedTx.contractCall.contractId} with ${parsedTx.contractCall.gas} gas`;
-      if (parsedTx.contractCall.amount > 0) {
-        contractCallSummary += ` and ${parsedTx.contractCall.amount} HBAR`;
-      }
-      if (parsedTx.contractCall.functionName) {
-        contractCallSummary += ` calling function ${parsedTx.contractCall.functionName}`;
-      }
-      return contractCallSummary;
-    } else if (parsedTx.tokenMint) {
-      return `Mint ${parsedTx.tokenMint.amount} tokens for token ${parsedTx.tokenMint.tokenId}`;
-    } else if (parsedTx.tokenBurn) {
-      return `Burn ${parsedTx.tokenBurn.amount} tokens for token ${parsedTx.tokenBurn.tokenId}`;
-    } else if (parsedTx.tokenCreation) {
-      let summary = `Create token ${parsedTx.tokenCreation.tokenName || "(No Name)"} (${parsedTx.tokenCreation.tokenSymbol || "(No Symbol)"})`;
-      if (parsedTx.tokenCreation.initialSupply) {
-        summary += ` with initial supply ${parsedTx.tokenCreation.initialSupply}`;
-      }
-      if (parsedTx.tokenCreation.customFees?.length) {
-        summary += ` including ${parsedTx.tokenCreation.customFees.length} custom fee(s)`;
-      }
-      return summary;
-    } else if (parsedTx.tokenTransfers.length > 0) {
-      const tokenGroups = {};
-      for (const transfer of parsedTx.tokenTransfers) {
-        if (!tokenGroups[transfer.tokenId]) {
-          tokenGroups[transfer.tokenId] = [];
+  static tryCreateKey(keyInput) {
+    try {
+      if (typeof keyInput === "string") {
+        let keyStr = keyInput.trim();
+        if (keyStr.toLowerCase().startsWith("0x")) {
+          keyStr = keyStr.substring(2);
         }
-        tokenGroups[transfer.tokenId].push(transfer);
-      }
-      const tokenSummaries = [];
-      for (const [tokenId, transfers] of Object.entries(tokenGroups)) {
-        const tokenSenders = [];
-        const tokenReceivers = [];
-        for (const transfer of transfers) {
-          const transferAmountValue = parseFloat(transfer.amount.toString());
-          if (transferAmountValue < 0) {
-            tokenSenders.push(
-              `${transfer.accountId} (${Math.abs(transferAmountValue)})`
-            );
-          } else if (transferAmountValue > 0) {
-            tokenReceivers.push(
-              `${transfer.accountId} (${transferAmountValue})`
-            );
+        if (this.isValidHex(keyStr) && keyStr.length === 64) {
+          const keyBytes = this.hexToBytes(keyStr);
+          const signatureResult = this.detectBySignature(keyStr);
+          if (signatureResult.type !== "unknown") {
+            return {
+              type: signatureResult.type,
+              format: "hex",
+              isPrivateKey: true,
+              rawBytes: keyBytes,
+              confidence: signatureResult.confidence,
+              warning: signatureResult.warning
+            };
           }
+          return {
+            type: "unknown",
+            format: "hex",
+            isPrivateKey: false,
+            rawBytes: keyBytes,
+            confidence: "certain"
+          };
         }
-        if (tokenSenders.length > 0 && tokenReceivers.length > 0) {
-          tokenSummaries.push(
-            `Transfer of token ${tokenId} from ${tokenSenders.join(
-              ", "
-            )} to ${tokenReceivers.join(", ")}`
-          );
-        }
-      }
-      if (tokenSummaries.length > 0) {
-        return tokenSummaries.join("; ");
-      } else {
-        return parsedTx.humanReadableType;
-      }
-    } else if (parsedTx.consensusCreateTopic) {
-      let summary = `Create new topic`;
-      if (parsedTx.consensusCreateTopic.memo) {
-        summary += ` with memo "${parsedTx.consensusCreateTopic.memo}"`;
-      }
-      if (parsedTx.consensusCreateTopic.autoRenewAccountId) {
-        summary += `, auto-renew by ${parsedTx.consensusCreateTopic.autoRenewAccountId}`;
-      }
-      return summary;
-    } else if (parsedTx.consensusSubmitMessage) {
-      let summary = `Submit message`;
-      if (parsedTx.consensusSubmitMessage.topicId) {
-        summary += ` to topic ${parsedTx.consensusSubmitMessage.topicId}`;
-      }
-      if (parsedTx.consensusSubmitMessage.message) {
-        if (parsedTx.consensusSubmitMessage.messageEncoding === "utf8") {
-          const messagePreview = parsedTx.consensusSubmitMessage.message.substring(0, 70);
-          summary += `: "${messagePreview}${parsedTx.consensusSubmitMessage.message.length > 70 ? "..." : ""}"`;
-        } else {
-          summary += ` (binary message data, length: ${Buffer.from(parsedTx.consensusSubmitMessage.message, "base64").length} bytes)`;
-        }
-      }
-      if (parsedTx.consensusSubmitMessage.chunkInfoNumber && parsedTx.consensusSubmitMessage.chunkInfoTotal) {
-        summary += ` (chunk ${parsedTx.consensusSubmitMessage.chunkInfoNumber}/${parsedTx.consensusSubmitMessage.chunkInfoTotal})`;
-      }
-      return summary;
-    } else if (parsedTx.fileCreate) {
-      let summary = "Create File";
-      if (parsedTx.fileCreate.memo) {
-        summary += ` with memo "${parsedTx.fileCreate.memo}"`;
-      }
-      if (parsedTx.fileCreate.contents) {
-        summary += ` (includes content)`;
-      }
-      return summary;
-    } else if (parsedTx.fileAppend) {
-      return `Append to File ${parsedTx.fileAppend.fileId || "(Unknown ID)"}`;
-    } else if (parsedTx.fileUpdate) {
-      return `Update File ${parsedTx.fileUpdate.fileId || "(Unknown ID)"}`;
-    } else if (parsedTx.fileDelete) {
-      return `Delete File ${parsedTx.fileDelete.fileId || "(Unknown ID)"}`;
-    } else if (parsedTx.consensusUpdateTopic) {
-      return `Update Topic ${parsedTx.consensusUpdateTopic.topicId || "(Unknown ID)"}`;
-    } else if (parsedTx.consensusDeleteTopic) {
-      return `Delete Topic ${parsedTx.consensusDeleteTopic.topicId || "(Unknown ID)"}`;
-    } else if (parsedTx.tokenUpdate) {
-      return `Update Token ${parsedTx.tokenUpdate.tokenId || "(Unknown ID)"}`;
-    } else if (parsedTx.tokenFeeScheduleUpdate) {
-      return `Update Fee Schedule for Token ${parsedTx.tokenFeeScheduleUpdate.tokenId || "(Unknown ID)"}`;
-    } else if (parsedTx.utilPrng) {
-      let summary = "Generate Random Number";
-      if (parsedTx.utilPrng.range && parsedTx.utilPrng.range > 0) {
-        summary += ` (range up to ${parsedTx.utilPrng.range - 1})`;
       }
-      return summary;
-    } else if (parsedTx.tokenFreeze) {
-      return `Freeze Token ${parsedTx.tokenFreeze.tokenId} for Account ${parsedTx.tokenFreeze.accountId}`;
-    } else if (parsedTx.tokenUnfreeze) {
-      return `Unfreeze Token ${parsedTx.tokenUnfreeze.tokenId} for Account ${parsedTx.tokenUnfreeze.accountId}`;
-    } else if (parsedTx.tokenGrantKyc) {
-      return `Grant KYC for Token ${parsedTx.tokenGrantKyc.tokenId} to Account ${parsedTx.tokenGrantKyc.accountId}`;
-    } else if (parsedTx.tokenRevokeKyc) {
-      return `Revoke KYC for Token ${parsedTx.tokenRevokeKyc.tokenId} from Account ${parsedTx.tokenRevokeKyc.accountId}`;
-    } else if (parsedTx.tokenPause) {
-      return `Pause Token ${parsedTx.tokenPause.tokenId}`;
-    } else if (parsedTx.tokenUnpause) {
-      return `Unpause Token ${parsedTx.tokenUnpause.tokenId}`;
-    } else if (parsedTx.tokenWipeAccount) {
-      let summary = `Wipe Token ${parsedTx.tokenWipeAccount.tokenId} from Account ${parsedTx.tokenWipeAccount.accountId}`;
-      if (parsedTx.tokenWipeAccount.serialNumbers?.length) {
-        summary += ` (Serials: ${parsedTx.tokenWipeAccount.serialNumbers.join(
-          ", "
-        )})`;
-      }
-      if (parsedTx.tokenWipeAccount.amount) {
-        summary += ` (Amount: ${parsedTx.tokenWipeAccount.amount})`;
-      }
-      return summary;
-    } else if (parsedTx.tokenDelete) {
-      return `Delete Token ${parsedTx.tokenDelete.tokenId}`;
-    } else if (parsedTx.tokenAssociate) {
-      return `Associate Account ${parsedTx.tokenAssociate.accountId} with Tokens: ${parsedTx.tokenAssociate.tokenIds?.join(", ")}`;
-    } else if (parsedTx.tokenDissociate) {
-      return `Dissociate Account ${parsedTx.tokenDissociate.accountId} from Tokens: ${parsedTx.tokenDissociate.tokenIds?.join(", ")}`;
-    } else if (parsedTx.cryptoDelete) {
-      return `Delete Account ${parsedTx.cryptoDelete.deleteAccountId}`;
+    } catch {
+    }
+    return {
+      type: "unknown",
+      format: "hex",
+      isPrivateKey: false,
+      rawBytes: new Uint8Array(),
+      confidence: "certain"
+    };
+  }
+  /**
+   * Detect key type by attempting to sign a message with both algorithms
+   *
+   * For ambiguous cases where both algorithms can use the key, this method
+   * uses heuristics to make a best-effort determination. For production use
+   * with ambiguous keys, consider using the Hedera mirror node to confirm
+   * the key type if you have the associated account ID.
+   *
+   * @param hexKey - The hex string representation of the key
+   * @returns Object containing type, confidence level, and optional warning
+   * @private
+   */
+  static detectBySignature(hexKey) {
+    const keyBigInt = BigInt("0x" + hexKey);
+    const secp256k1Order = BigInt(
+      "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141"
+    );
+    if (keyBigInt === 0n) {
+      return {
+        type: "ed25519",
+        confidence: "certain"
+      };
+    }
+    if (keyBigInt >= secp256k1Order) {
+      return {
+        type: "ed25519",
+        confidence: "certain"
+      };
     }
-    if (parsedTx.cryptoCreateAccount) {
-      let summary = "Create Account";
-      if (parsedTx.cryptoCreateAccount.initialBalance && parsedTx.cryptoCreateAccount.initialBalance !== "0") {
-        summary += ` with balance ${parsedTx.cryptoCreateAccount.initialBalance}`;
+    let ed25519CanSign = false;
+    let ecdsaCanSign = false;
+    try {
+      const ed25519Key = PrivateKey.fromStringED25519(hexKey);
+      const testMessage = new Uint8Array([1, 2, 3, 4, 5]);
+      const signature = ed25519Key.sign(testMessage);
+      if (ed25519Key.publicKey.verify(testMessage, signature)) {
+        ed25519CanSign = true;
       }
-      if (parsedTx.cryptoCreateAccount.alias) {
-        summary += ` (Alias: ${parsedTx.cryptoCreateAccount.alias})`;
+    } catch {
+    }
+    try {
+      const ecdsaKey = PrivateKey.fromStringECDSA(hexKey);
+      const testMessage = new Uint8Array([1, 2, 3, 4, 5]);
+      const signature = ecdsaKey.sign(testMessage);
+      if (ecdsaKey.publicKey.verify(testMessage, signature)) {
+        ecdsaCanSign = true;
       }
-      return summary;
+    } catch {
     }
-    if (parsedTx.cryptoUpdateAccount) {
-      return `Update Account ${parsedTx.cryptoUpdateAccount.accountIdToUpdate || "(Unknown ID)"}`;
+    if (ed25519CanSign && ecdsaCanSign) {
+      const keyBytes = this.hexToBytes(hexKey);
+      if (keyBytes[0] === 168 && keyBytes[1] === 1) {
+        return {
+          type: "ed25519",
+          confidence: "uncertain",
+          warning: "Detection based on byte pattern heuristic. Both ED25519 and ECDSA accept this key."
+        };
+      }
+      let highBytes = 0;
+      for (const byte of keyBytes) {
+        if (byte >= 128) highBytes++;
+      }
+      const highByteRatio = highBytes / keyBytes.length;
+      if (highByteRatio >= 0.4 && highByteRatio <= 0.6) {
+        return {
+          type: "ecdsa",
+          confidence: "uncertain",
+          warning: "Detection based on entropy heuristic. Both ED25519 and ECDSA accept this key."
+        };
+      }
+      return {
+        type: "ecdsa",
+        confidence: "uncertain",
+        warning: "Detection based on entropy heuristic. Both ED25519 and ECDSA accept this key. Defaulting to ECDSA."
+      };
     }
-    if (parsedTx.cryptoApproveAllowance) {
-      let count = (parsedTx.cryptoApproveAllowance.hbarAllowances?.length || 0) + (parsedTx.cryptoApproveAllowance.tokenAllowances?.length || 0) + (parsedTx.cryptoApproveAllowance.nftAllowances?.length || 0);
-      return `Approve ${count} Crypto Allowance(s)`;
+    if (ed25519CanSign && !ecdsaCanSign) {
+      return {
+        type: "ed25519",
+        confidence: "certain"
+      };
     }
-    if (parsedTx.cryptoDeleteAllowance) {
-      return `Delete ${parsedTx.cryptoDeleteAllowance.nftAllowancesToRemove?.length || 0} NFT Crypto Allowance(s)`;
+    if (ecdsaCanSign && !ed25519CanSign) {
+      return {
+        type: "ecdsa",
+        confidence: "certain"
+      };
     }
-    if (parsedTx.contractCreate) {
-      let summary = "Create Contract";
-      if (parsedTx.contractCreate.memo) {
-        summary += ` (Memo: ${parsedTx.contractCreate.memo})`;
-      }
-      return summary;
+    return {
+      type: "unknown",
+      confidence: "certain"
+    };
+  }
+  /**
+   * Check if a string is valid hexadecimal with even length
+   *
+   * @param str - The string to check
+   * @returns True if the string is valid hex with even length
+   * @private
+   */
+  static isValidHex(str) {
+    return /^[0-9a-fA-F]+$/.test(str) && str.length % 2 === 0;
+  }
+  /**
+   * Check if a string is valid base64
+   *
+   * @param str - The string to check
+   * @returns True if the string is valid base64
+   * @private
+   */
+  static isBase64(str) {
+    try {
+      return Buffer.from(str, "base64").toString("base64") === str;
+    } catch {
+      return false;
     }
-    if (parsedTx.contractUpdate) {
-      return `Update Contract ${parsedTx.contractUpdate.contractIdToUpdate || "(Unknown ID)"}`;
+  }
+  /**
+   * Convert a hex string to bytes
+   *
+   * @param hex - The hex string to convert
+   * @returns Uint8Array of bytes
+   * @private
+   */
+  static hexToBytes(hex) {
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2) {
+      bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
     }
-    if (parsedTx.contractDelete) {
-      let summary = `Delete Contract ${parsedTx.contractDelete.contractIdToDelete || "(Unknown ID)"}`;
-      if (parsedTx.contractDelete.transferAccountId) {
-        summary += ` (Transfer to Account: ${parsedTx.contractDelete.transferAccountId})`;
-      } else if (parsedTx.contractDelete.transferContractId) {
-        summary += ` (Transfer to Contract: ${parsedTx.contractDelete.transferContractId})`;
-      }
-      return summary;
+    return bytes;
+  }
+  /**
+   * Check if bytes start with a specific prefix
+   *
+   * @param bytes - The bytes to check
+   * @param prefix - The prefix to look for
+   * @returns True if bytes start with the prefix
+   * @private
+   */
+  static hasPrefix(bytes, prefix) {
+    if (bytes.length < prefix.length) return false;
+    for (let i = 0; i < prefix.length; i++) {
+      if (bytes[i] !== prefix[i]) return false;
     }
-    if (parsedTx.humanReadableType && parsedTx.humanReadableType !== "Unknown Transaction") {
-      return parsedTx.humanReadableType;
+    return true;
+  }
+  /**
+   * Check if bytes contain an ECDSA private key pattern
+   *
+   * @param bytes - The bytes to check
+   * @returns True if ECDSA private key pattern is found
+   * @private
+   */
+  static containsECDSAPrivateKeyPattern(bytes) {
+    for (let i = 0; i < bytes.length - 7; i++) {
+      if (bytes[i] === 48 && bytes[i + 1] === 116 && bytes[i + 2] === 2 && bytes[i + 3] === 1 && bytes[i + 4] === 1 && bytes[i + 5] === 4 && bytes[i + 6] === 32) {
+        return true;
+      }
     }
-    if (parsedTx.tokenTransfers.length > 0) {
-      const tokenGroups = {};
-      for (const transfer of parsedTx.tokenTransfers) {
-        if (!tokenGroups[transfer.tokenId]) {
-          tokenGroups[transfer.tokenId] = [];
-        }
-        tokenGroups[transfer.tokenId].push(transfer);
+    return false;
+  }
+  /**
+   * Extract ECDSA private key from DER structure
+   *
+   * @param bytes - The DER encoded bytes
+   * @returns The extracted private key bytes
+   * @private
+   */
+  static extractECDSAPrivateKey(bytes) {
+    for (let i = 0; i < bytes.length - 32; i++) {
+      if (bytes[i] === 4 && bytes[i + 1] === 32) {
+        return bytes.slice(i + 2, i + 34);
       }
-      const tokenSummaries = [];
-      for (const [tokenId, transfers] of Object.entries(tokenGroups)) {
-        const tokenSenders = transfers.filter((t) => t.amount < 0).map((t) => `${t.accountId} (${Math.abs(t.amount)})`);
-        const tokenReceivers = transfers.filter((t) => t.amount > 0).map((t) => `${t.accountId} (${t.amount})`);
-        if (tokenSenders.length > 0 && tokenReceivers.length > 0) {
-          tokenSummaries.push(
-            `Transfer of token ${tokenId} from ${tokenSenders.join(
-              ", "
-            )} to ${tokenReceivers.join(", ")}`
-          );
-        } else if (tokenReceivers.length > 0) {
-          tokenSummaries.push(
-            `Token ${tokenId} received by ${tokenReceivers.join(", ")}`
-          );
-        } else if (tokenSenders.length > 0) {
-          tokenSummaries.push(
-            `Token ${tokenId} sent from ${tokenSenders.join(", ")}`
-          );
-        }
+    }
+    return bytes;
+  }
+};
+_KeyTypeDetector.ED25519_PUBLIC_KEY_LENGTH = 32;
+_KeyTypeDetector.ED25519_EXPANDED_PRIVATE_KEY_LENGTH = 64;
+_KeyTypeDetector.ED25519_PUBLIC_KEY_PREFIX = Buffer.from([
+  48,
+  42,
+  48,
+  5,
+  6,
+  3,
+  43,
+  101,
+  112,
+  3,
+  33,
+  0
+]);
+_KeyTypeDetector.ED25519_PRIVATE_KEY_PREFIX = Buffer.from([
+  48,
+  46,
+  2,
+  1,
+  0,
+  48,
+  5,
+  6,
+  3,
+  43,
+  101,
+  112,
+  4,
+  34,
+  4,
+  32
+]);
+_KeyTypeDetector.ECDSA_SECP256K1_PUBLIC_KEY_PREFIX = Buffer.from([
+  48,
+  86,
+  48,
+  16,
+  6,
+  7,
+  42,
+  134,
+  72,
+  206,
+  61,
+  2,
+  1,
+  6,
+  5,
+  43,
+  129,
+  4,
+  0,
+  10,
+  3,
+  66,
+  0
+]);
+_KeyTypeDetector.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX = Buffer.from([
+  48,
+  116,
+  2,
+  1,
+  1,
+  4,
+  32
+]);
+_KeyTypeDetector.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX_SHORT = Buffer.from([
+  48,
+  48,
+  2,
+  1,
+  0,
+  48,
+  7,
+  6,
+  5,
+  43,
+  129,
+  4,
+  0,
+  10,
+  4,
+  34,
+  4,
+  32
+]);
+_KeyTypeDetector.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX_LONG = Buffer.from(
+  [48, 119, 2, 1, 1, 4, 32]
+);
+let KeyTypeDetector = _KeyTypeDetector;
+function detectKeyTypeFromString(privateKeyString) {
+  const keyInfo = KeyTypeDetector.detect(privateKeyString);
+  if (keyInfo.type !== "unknown") {
+    try {
+      const privateKey = keyInfo.type === "ecdsa" ? PrivateKey.fromStringECDSA(privateKeyString) : PrivateKey.fromStringED25519(privateKeyString);
+      const result = {
+        detectedType: keyInfo.type,
+        privateKey
+      };
+      if (keyInfo.confidence === "uncertain") {
+        result.warning = `Key type detection is uncertain. If you have the associated account ID, consider using the Hedera mirror node to confirm the key type.`;
       }
-      if (tokenSummaries.length > 0) return tokenSummaries.join("; ");
+      return result;
+    } catch (error) {
+    }
+  }
+  try {
+    const privateKey = PrivateKey.fromStringECDSA(privateKeyString);
+    return {
+      detectedType: "ecdsa",
+      privateKey,
+      warning: `Using ECDSA as default. If you have the associated account ID, consider using the Hedera mirror node to confirm the key type.`
+    };
+  } catch (ecdsaError) {
+    try {
+      const privateKey = PrivateKey.fromStringED25519(privateKeyString);
+      return {
+        detectedType: "ed25519",
+        privateKey,
+        warning: `Using ED25519 as fallback. If you have the associated account ID, consider using the Hedera mirror node to confirm the key type.`
+      };
+    } catch (ed25519Error) {
+      throw new Error(
+        `Failed to parse private key as either ECDSA or ED25519: ${ecdsaError}`
+      );
     }
-    return "Unknown Transaction";
   }
 }
 export {
-  TransactionParser
+  KeyType,
+  KeyTypeDetector,
+  detectKeyTypeFromString
 };
 //# sourceMappingURL=standards-sdk.es39.js.map