@hashgraphonline/standards-sdk 0.1.143 → 0.1.144-feat-solana-register.canary.5001619.81

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

@@ -1,570 +1,605 @@
-const getNested = (tx, path) => {
-  const parts = path.split(".");
-  let current = tx;
-  for (const p of parts) {
-    if (current == null) {
-      return void 0;
+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 {
+  /**
+   * 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 detect(keyInput) {
+    try {
+      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 this.detectFromBytes(keyBytes, originalFormat);
+    } catch (error) {
+      return {
+        type: "unknown",
+        format: "raw",
+        isPrivateKey: false,
+        confidence: "certain"
+      };
     }
-    current = current[p];
   }
-  return current;
-};
-const renderTemplate = (template, tx) => {
-  return template.replace(/\{([^}]+)\}/g, (_m, path) => {
-    const value = getNested(tx, String(path).trim());
-    if (value === null || value === void 0) {
-      return "(Unknown)";
+  /**
+   * 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 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"
+      };
     }
-    return String(value);
-  });
-};
-const summarizeCryptoTransfer = (tx) => {
-  const senders = [];
-  const receivers = [];
-  if (Array.isArray(tx.transfers)) {
-    for (const transfer of tx.transfers) {
-      const originalAmountFloat = parseFloat(transfer.amount);
-      let displayStr = transfer.amount;
-      if (displayStr.startsWith("-")) {
-        displayStr = displayStr.substring(1);
+    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"
+        };
       }
-      displayStr = displayStr.replace(/\s*ℏ$/, "");
-      if (originalAmountFloat < 0) {
-        senders.push(`${transfer.accountId} (${displayStr} ℏ)`);
-      } else if (originalAmountFloat > 0) {
-        receivers.push(`${transfer.accountId} (${displayStr} ℏ)`);
+    }
+    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 {
+      type: "unknown",
+      format,
+      isPrivateKey: false,
+      rawBytes: bytes,
+      confidence: "certain"
+    };
+  }
+  /**
+   * Detect key type from PEM format
+   *
+   * @param pem - The PEM-encoded key string
+   * @returns KeyInfo object with detection results
+   * @private
+   */
+  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 isECKey = false;
+    for (const [type, regex] of Object.entries(pemTypes)) {
+      if (regex.test(trimmedPem) && type.includes("EC")) {
+        isECKey = true;
+        break;
       }
     }
-  }
-  if (senders.length > 0 && receivers.length > 0) {
-    return `Transfer of HBAR from ${senders.join(", ")} to ${receivers.join(", ")}`;
-  }
-  return tx.humanReadableType;
-};
-const groupTokenTransfers = (tokenTransfers) => {
-  const groups = {};
-  for (const t of tokenTransfers) {
-    if (!groups[t.tokenId]) {
-      groups[t.tokenId] = [];
+    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"
+      };
     }
-    groups[t.tokenId].push(t);
   }
-  return groups;
-};
-const summarizeTokenTransfers = (tx) => {
-  const tokenSummaries = [];
-  const groups = groupTokenTransfers(tx.tokenTransfers || []);
-  for (const [tokenId, transfers] of Object.entries(groups)) {
-    const tokenSenders = [];
-    const tokenReceivers = [];
-    for (const t of transfers) {
-      const amt = parseFloat(String(t.amount));
-      if (amt < 0) {
-        tokenSenders.push(`${t.accountId} (${Math.abs(amt)})`);
-      } else if (amt > 0) {
-        tokenReceivers.push(`${t.accountId} (${amt})`);
+  /**
+   * 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 tryCreateKey(keyInput) {
+    try {
+      if (typeof keyInput === "string") {
+        let keyStr = keyInput.trim();
+        if (keyStr.toLowerCase().startsWith("0x")) {
+          keyStr = keyStr.substring(2);
+        }
+        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"
+          };
+        }
       }
+    } catch {
     }
-    if (tokenSenders.length > 0 && tokenReceivers.length > 0) {
-      tokenSummaries.push(
-        `Transfer of token ${tokenId} from ${tokenSenders.join(", ")} to ${tokenReceivers.join(", ")}`
-      );
+    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 (tokenSummaries.length > 0) {
-    return tokenSummaries.join("; ");
-  }
-  return tx.humanReadableType;
-};
-const summarizeContractCall = (tx) => {
-  if (!tx.contractCall) {
-    return tx.humanReadableType;
-  }
-  let summary = `Contract call to ${tx.contractCall.contractId} with ${tx.contractCall.gas} gas`;
-  if (tx.contractCall.amount > 0) {
-    summary += ` and ${tx.contractCall.amount} HBAR`;
-  }
-  if (tx.contractCall.functionName) {
-    summary += ` calling function ${tx.contractCall.functionName}`;
-  }
-  return summary;
-};
-const summarizeTokenMint = (tx) => {
-  if (tx.tokenMint) {
-    return `Mint ${tx.tokenMint.amount} tokens for token ${tx.tokenMint.tokenId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenBurn = (tx) => {
-  if (tx.tokenBurn) {
-    return `Burn ${tx.tokenBurn.amount} tokens for token ${tx.tokenBurn.tokenId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenCreate = (tx) => {
-  if (!tx.tokenCreation) {
-    return tx.humanReadableType;
-  }
-  let summary = `Create token ${tx.tokenCreation.tokenName || "(No Name)"} (${tx.tokenCreation.tokenSymbol || "(No Symbol)"})`;
-  if (tx.tokenCreation.initialSupply) {
-    summary += ` with initial supply ${tx.tokenCreation.initialSupply}`;
-  }
-  if (tx.tokenCreation.customFees && tx.tokenCreation.customFees.length > 0) {
-    summary += ` including ${tx.tokenCreation.customFees.length} custom fee(s)`;
-  }
-  return summary;
-};
-const summarizeConsensusCreateTopic = (tx) => {
-  if (!tx.consensusCreateTopic) {
-    return tx.humanReadableType;
-  }
-  let summary = "Create new topic";
-  if (tx.consensusCreateTopic.memo) {
-    summary += ` with memo "${tx.consensusCreateTopic.memo}"`;
-  }
-  if (tx.consensusCreateTopic.autoRenewAccountId) {
-    summary += `, auto-renew by ${tx.consensusCreateTopic.autoRenewAccountId}`;
-  }
-  return summary;
-};
-const summarizeConsensusSubmitMessage = (tx) => {
-  if (!tx.consensusSubmitMessage) {
-    return tx.humanReadableType;
-  }
-  let summary = "Submit message";
-  if (tx.consensusSubmitMessage.topicId) {
-    summary += ` to topic ${tx.consensusSubmitMessage.topicId}`;
-  }
-  if (tx.consensusSubmitMessage.message) {
-    if (tx.consensusSubmitMessage.messageEncoding === "utf8") {
-      const preview = tx.consensusSubmitMessage.message.substring(0, 70);
-      const needsEllipsis = tx.consensusSubmitMessage.message.length > 70;
-      summary += `: "${preview}${needsEllipsis ? "..." : ""}"`;
-    } else {
-      const byteLength = Buffer.from(
-        tx.consensusSubmitMessage.message,
-        "base64"
-      ).length;
-      summary += ` (binary message data, length: ${byteLength} bytes)`;
+    if (keyBigInt >= secp256k1Order) {
+      return {
+        type: "ed25519",
+        confidence: "certain"
+      };
     }
-  }
-  if (tx.consensusSubmitMessage.chunkInfoNumber && tx.consensusSubmitMessage.chunkInfoTotal) {
-    summary += ` (chunk ${tx.consensusSubmitMessage.chunkInfoNumber}/${tx.consensusSubmitMessage.chunkInfoTotal})`;
-  }
-  return summary;
-};
-const summarizeFileCreate = (tx) => {
-  if (!tx.fileCreate) {
-    return tx.humanReadableType;
-  }
-  let summary = "Create File";
-  if (tx.fileCreate.memo) {
-    summary += ` with memo "${tx.fileCreate.memo}"`;
-  }
-  if (tx.fileCreate.contents) {
-    summary += " (includes content)";
-  }
-  return summary;
-};
-const summarizeFileAppend = (tx) => {
-  if (tx.fileAppend) {
-    return `Append to File ${tx.fileAppend.fileId || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeFileUpdate = (tx) => {
-  if (tx.fileUpdate) {
-    return `Update File ${tx.fileUpdate.fileId || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeFileDelete = (tx) => {
-  if (tx.fileDelete) {
-    return `Delete File ${tx.fileDelete.fileId || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeConsensusUpdateTopic = (tx) => {
-  if (tx.consensusUpdateTopic) {
-    return `Update Topic ${tx.consensusUpdateTopic.topicId || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeConsensusDeleteTopic = (tx) => {
-  if (tx.consensusDeleteTopic) {
-    return `Delete Topic ${tx.consensusDeleteTopic.topicId || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenFreeze = (tx) => {
-  if (tx.tokenFreeze) {
-    return `Freeze Token ${tx.tokenFreeze.tokenId} for Account ${tx.tokenFreeze.accountId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenUnfreeze = (tx) => {
-  if (tx.tokenUnfreeze) {
-    return `Unfreeze Token ${tx.tokenUnfreeze.tokenId} for Account ${tx.tokenUnfreeze.accountId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenGrantKyc = (tx) => {
-  if (tx.tokenGrantKyc) {
-    return `Grant KYC for Token ${tx.tokenGrantKyc.tokenId} to Account ${tx.tokenGrantKyc.accountId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenRevokeKyc = (tx) => {
-  if (tx.tokenRevokeKyc) {
-    return `Revoke KYC for Token ${tx.tokenRevokeKyc.tokenId} from Account ${tx.tokenRevokeKyc.accountId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenPause = (tx) => {
-  if (tx.tokenPause) {
-    return `Pause Token ${tx.tokenPause.tokenId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenUnpause = (tx) => {
-  if (tx.tokenUnpause) {
-    return `Unpause Token ${tx.tokenUnpause.tokenId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenWipe = (tx) => {
-  if (tx.tokenWipeAccount) {
-    let summary = `Wipe Token ${tx.tokenWipeAccount.tokenId} from Account ${tx.tokenWipeAccount.accountId}`;
-    if (tx.tokenWipeAccount.serialNumbers && tx.tokenWipeAccount.serialNumbers.length > 0) {
-      summary += ` (Serials: ${tx.tokenWipeAccount.serialNumbers.join(", ")})`;
+    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;
+      }
+    } catch {
     }
-    if (tx.tokenWipeAccount.amount) {
-      summary += ` (Amount: ${tx.tokenWipeAccount.amount})`;
+    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;
+      }
+    } catch {
     }
-    return summary;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenDelete = (tx) => {
-  if (tx.tokenDelete) {
-    return `Delete Token ${tx.tokenDelete.tokenId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenAssociate = (tx) => {
-  if (tx.tokenAssociate) {
-    return `Associate Account ${tx.tokenAssociate.accountId} with Tokens: ${(tx.tokenAssociate.tokenIds || []).join(", ")}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenDissociate = (tx) => {
-  if (tx.tokenDissociate) {
-    return `Dissociate Account ${tx.tokenDissociate.accountId} from Tokens: ${(tx.tokenDissociate.tokenIds || []).join(", ")}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeAccountDelete = (tx) => {
-  if (tx.cryptoDelete) {
-    return `Delete Account ${tx.cryptoDelete.deleteAccountId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeAccountCreate = (tx) => {
-  if (!tx.cryptoCreateAccount) {
-    return tx.humanReadableType;
-  }
-  let summary = "Create Account";
-  if (tx.cryptoCreateAccount.initialBalance && tx.cryptoCreateAccount.initialBalance !== "0") {
-    summary += ` with balance ${tx.cryptoCreateAccount.initialBalance}`;
-  }
-  if (tx.cryptoCreateAccount.alias) {
-    summary += ` (Alias: ${tx.cryptoCreateAccount.alias})`;
-  }
-  return summary;
-};
-const summarizeAccountUpdate = (tx) => {
-  if (tx.cryptoUpdateAccount) {
-    return `Update Account ${tx.cryptoUpdateAccount.accountIdToUpdate || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeApproveAllowance = (tx) => {
-  if (tx.cryptoApproveAllowance) {
-    let count = 0;
-    if (tx.cryptoApproveAllowance.hbarAllowances) {
-      count += tx.cryptoApproveAllowance.hbarAllowances.length;
+    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 (tx.cryptoApproveAllowance.tokenAllowances) {
-      count += tx.cryptoApproveAllowance.tokenAllowances.length;
+    if (ed25519CanSign && !ecdsaCanSign) {
+      return {
+        type: "ed25519",
+        confidence: "certain"
+      };
     }
-    if (tx.cryptoApproveAllowance.nftAllowances) {
-      count += tx.cryptoApproveAllowance.nftAllowances.length;
+    if (ecdsaCanSign && !ed25519CanSign) {
+      return {
+        type: "ecdsa",
+        confidence: "certain"
+      };
     }
-    return `Approve ${count} Crypto Allowance(s)`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeDeleteAllowance = (tx) => {
-  if (tx.cryptoDeleteAllowance) {
-    const count = (tx.cryptoDeleteAllowance.nftAllowancesToRemove || []).length;
-    return `Delete ${count} NFT Crypto Allowance(s)`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeContractCreate = (tx) => {
-  if (tx.contractCreate) {
-    let summary = "Create Contract";
-    if (tx.contractCreate.memo) {
-      summary += ` (Memo: ${tx.contractCreate.memo})`;
+    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;
     }
-    return summary;
   }
-  return tx.humanReadableType;
-};
-const summarizeContractUpdate = (tx) => {
-  if (tx.contractUpdate) {
-    return `Update Contract ${tx.contractUpdate.contractIdToUpdate || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeContractDelete = (tx) => {
-  if (tx.contractDelete) {
-    let summary = `Delete Contract ${tx.contractDelete.contractIdToDelete || "(Unknown ID)"}`;
-    if (tx.contractDelete.transferAccountId) {
-      summary += ` (Transfer to Account: ${tx.contractDelete.transferAccountId})`;
-    } else if (tx.contractDelete.transferContractId) {
-      summary += ` (Transfer to Contract: ${tx.contractDelete.transferContractId})`;
+  /**
+   * 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);
     }
-    return summary;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenUpdate = (tx) => {
-  if (tx.tokenUpdate) {
-    return `Update Token ${tx.tokenUpdate.tokenId || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenFeeScheduleUpdate = (tx) => {
-  if (tx.tokenFeeScheduleUpdate) {
-    return `Update Fee Schedule for Token ${tx.tokenFeeScheduleUpdate.tokenId || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenAirdrop = (tx) => {
-  if (!tx.tokenAirdrop || !tx.tokenAirdrop.tokenTransfers) {
-    return tx.humanReadableType;
-  }
-  let tokenTypes = 0;
-  let totalTransfers = 0;
-  for (const t of tx.tokenAirdrop.tokenTransfers) {
-    tokenTypes += 1;
-    totalTransfers += Array.isArray(t.transfers) ? t.transfers.length : 0;
-  }
-  return `Token Airdrop across ${tokenTypes} token(s), ${totalTransfers} transfer(s)`;
-};
-const summarizeScheduleCreate = (tx) => {
-  if (!tx.scheduleCreate) {
-    return tx.humanReadableType;
-  }
-  let summary = "Create Schedule";
-  if (tx.scheduleCreate.memo) {
-    summary += ` (Memo: ${tx.scheduleCreate.memo})`;
-  }
-  return summary;
-};
-const summarizeScheduleSign = (tx) => {
-  if (tx.scheduleSign) {
-    return "Sign Schedule";
-  }
-  return tx.humanReadableType;
-};
-const summarizeScheduleDelete = (tx) => {
-  if (tx.scheduleDelete) {
-    return "Delete Schedule";
-  }
-  return tx.humanReadableType;
-};
-const summarizeSystemDelete = (tx) => {
-  if (!tx.systemDelete) {
-    return tx.humanReadableType;
-  }
-  if (tx.systemDelete.fileId) {
-    return `System Delete File ${tx.systemDelete.fileId}`;
-  }
-  if (tx.systemDelete.contractId) {
-    return `System Delete Contract ${tx.systemDelete.contractId}`;
-  }
-  return "System Delete";
-};
-const summarizeSystemUndelete = (tx) => {
-  if (!tx.systemUndelete) {
-    return tx.humanReadableType;
-  }
-  if (tx.systemUndelete.fileId) {
-    return `System Undelete File ${tx.systemUndelete.fileId}`;
-  }
-  if (tx.systemUndelete.contractId) {
-    return `System Undelete Contract ${tx.systemUndelete.contractId}`;
-  }
-  return "System Undelete";
-};
-const summarizeFreeze = (tx) => {
-  return "Network Freeze";
-};
-const summarizeEthereumTransaction = (tx) => {
-  return "Ethereum Transaction";
-};
-const summarizeUncheckedSubmit = (tx) => {
-  if (tx.uncheckedSubmit && tx.uncheckedSubmit.topicId) {
-    return `Unchecked Submit to topic ${tx.uncheckedSubmit.topicId}`;
-  }
-  return "Unchecked Submit";
-};
-const summarizeNodeCreate = (tx) => {
-  return "Create Node";
-};
-const summarizeNodeUpdate = (tx) => {
-  return "Update Node";
-};
-const summarizeNodeDelete = (tx) => {
-  return "Delete Node";
-};
-const summarizeAtomicBatch = (tx) => {
-  const count = Array.isArray(tx.atomicBatch?.transactions) ? tx.atomicBatch.transactions.length : 0;
-  return `Atomic Batch (${count} transaction(s))`;
-};
-const transactionSummaryRegistry = {
-  CRYPTOTRANSFER: { fn: summarizeCryptoTransfer },
-  cryptoTransfer: { fn: summarizeCryptoTransfer },
-  CONTRACTCALL: { fn: summarizeContractCall },
-  contractCall: { fn: summarizeContractCall },
-  TOKENMINT: { fn: summarizeTokenMint },
-  tokenMint: { fn: summarizeTokenMint },
-  TOKENBURN: { fn: summarizeTokenBurn },
-  tokenBurn: { fn: summarizeTokenBurn },
-  TOKENCREATE: { fn: summarizeTokenCreate },
-  tokenCreation: { fn: summarizeTokenCreate },
-  TOPICCREATE: { fn: summarizeConsensusCreateTopic },
-  consensusCreateTopic: { fn: summarizeConsensusCreateTopic },
-  CONSENSUSSUBMITMESSAGE: { fn: summarizeConsensusSubmitMessage },
-  consensusSubmitMessage: { fn: summarizeConsensusSubmitMessage },
-  TOPICUPDATE: { fn: summarizeConsensusUpdateTopic },
-  consensusUpdateTopic: { fn: summarizeConsensusUpdateTopic },
-  TOPICDELETE: { fn: summarizeConsensusDeleteTopic },
-  consensusDeleteTopic: { fn: summarizeConsensusDeleteTopic },
-  FILECREATE: { fn: summarizeFileCreate },
-  fileCreate: { fn: summarizeFileCreate },
-  FILEAPPEND: { fn: summarizeFileAppend },
-  fileAppend: { fn: summarizeFileAppend },
-  FILEUPDATE: { fn: summarizeFileUpdate },
-  fileUpdate: { fn: summarizeFileUpdate },
-  FILEDELETE: { fn: summarizeFileDelete },
-  fileDelete: { fn: summarizeFileDelete },
-  TOKENUPDATE: { fn: summarizeTokenUpdate },
-  tokenUpdate: { fn: summarizeTokenUpdate },
-  TOKENFEESCHEDULEUPDATE: { fn: summarizeTokenFeeScheduleUpdate },
-  tokenFeeScheduleUpdate: { fn: summarizeTokenFeeScheduleUpdate },
-  TOKENFREEZE: { fn: summarizeTokenFreeze },
-  tokenFreeze: { fn: summarizeTokenFreeze },
-  TOKENUNFREEZE: { fn: summarizeTokenUnfreeze },
-  tokenUnfreeze: { fn: summarizeTokenUnfreeze },
-  TOKENGRANTKYC: { fn: summarizeTokenGrantKyc },
-  tokenGrantKyc: { fn: summarizeTokenGrantKyc },
-  TOKENREVOKEKYC: { fn: summarizeTokenRevokeKyc },
-  tokenRevokeKyc: { fn: summarizeTokenRevokeKyc },
-  TOKENPAUSE: { fn: summarizeTokenPause },
-  tokenPause: { fn: summarizeTokenPause },
-  TOKENUNPAUSE: { fn: summarizeTokenUnpause },
-  tokenUnpause: { fn: summarizeTokenUnpause },
-  TOKENWIPE: { fn: summarizeTokenWipe },
-  TOKENWIPEACCOUNT: { fn: summarizeTokenWipe },
-  tokenWipe: { fn: summarizeTokenWipe },
-  tokenWipeAccount: { fn: summarizeTokenWipe },
-  TOKENDELETE: { fn: summarizeTokenDelete },
-  tokenDelete: { fn: summarizeTokenDelete },
-  TOKENASSOCIATE: { fn: summarizeTokenAssociate },
-  tokenAssociate: { fn: summarizeTokenAssociate },
-  TOKENDISSOCIATE: { fn: summarizeTokenDissociate },
-  tokenDissociate: { fn: summarizeTokenDissociate },
-  ACCOUNTDELETE: { fn: summarizeAccountDelete },
-  cryptoDelete: { fn: summarizeAccountDelete },
-  ACCOUNTCREATE: { fn: summarizeAccountCreate },
-  cryptoCreateAccount: { fn: summarizeAccountCreate },
-  ACCOUNTUPDATE: { fn: summarizeAccountUpdate },
-  cryptoUpdateAccount: { fn: summarizeAccountUpdate },
-  APPROVEALLOWANCE: { fn: summarizeApproveAllowance },
-  cryptoApproveAllowance: { fn: summarizeApproveAllowance },
-  DELETEALLOWANCE: { fn: summarizeDeleteAllowance },
-  cryptoDeleteAllowance: { fn: summarizeDeleteAllowance },
-  CONTRACTCREATE: { fn: summarizeContractCreate },
-  contractCreate: { fn: summarizeContractCreate },
-  CONTRACTUPDATE: { fn: summarizeContractUpdate },
-  contractUpdate: { fn: summarizeContractUpdate },
-  CONTRACTDELETE: { fn: summarizeContractDelete },
-  contractDelete: { fn: summarizeContractDelete },
-  TOKENAIRDROP: { fn: summarizeTokenAirdrop },
-  tokenAirdrop: { fn: summarizeTokenAirdrop },
-  SCHEDULECREATE: { fn: summarizeScheduleCreate },
-  scheduleCreate: { fn: summarizeScheduleCreate },
-  SCHEDULESIGN: { fn: summarizeScheduleSign },
-  scheduleSign: { fn: summarizeScheduleSign },
-  SCHEDULEDELETE: { fn: summarizeScheduleDelete },
-  scheduleDelete: { fn: summarizeScheduleDelete },
-  SYSTEMDELETE: { fn: summarizeSystemDelete },
-  systemDelete: { fn: summarizeSystemDelete },
-  SYSTEMUNDELETE: { fn: summarizeSystemUndelete },
-  systemUndelete: { fn: summarizeSystemUndelete },
-  FREEZE: { fn: summarizeFreeze },
-  freeze: { fn: summarizeFreeze },
-  ETHEREUMTRANSACTION: { fn: summarizeEthereumTransaction },
-  ethereumTransaction: { fn: summarizeEthereumTransaction },
-  UNCHECKEDSUBMIT: { fn: summarizeUncheckedSubmit },
-  uncheckedSubmit: { fn: summarizeUncheckedSubmit },
-  NODECREATE: { fn: summarizeNodeCreate },
-  nodeCreate: { fn: summarizeNodeCreate },
-  NODEUPDATE: { fn: summarizeNodeUpdate },
-  nodeUpdate: { fn: summarizeNodeUpdate },
-  NODEDELETE: { fn: summarizeNodeDelete },
-  nodeDelete: { fn: summarizeNodeDelete },
-  ATOMICBATCH: { fn: summarizeAtomicBatch },
-  atomicBatch: { fn: summarizeAtomicBatch }
-};
-const resolveTransactionSummary = (tx) => {
-  const spec = transactionSummaryRegistry[tx.type];
-  if (spec) {
-    if (spec.fn) {
-      return spec.fn(tx);
+    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 (spec.template) {
-      return renderTemplate(spec.template, tx);
+    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;
+      }
     }
-  }
-  const hrSpec = transactionSummaryRegistry[tx.humanReadableType];
-  if (hrSpec) {
-    if (hrSpec.fn) {
-      return hrSpec.fn(tx);
+    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);
+      }
     }
-    if (hrSpec.template) {
-      return renderTemplate(hrSpec.template, tx);
+    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.`;
+      }
+      return result;
+    } catch (error) {
     }
   }
-  if (tx.type === "cryptoTransfer" || tx.type === "CRYPTOTRANSFER") {
-    return summarizeCryptoTransfer(tx);
-  }
-  if (tx.contractCall) {
-    return summarizeContractCall(tx);
-  }
-  if (Array.isArray(tx.tokenTransfers) && tx.tokenTransfers.length > 0) {
-    return summarizeTokenTransfers(tx);
-  }
-  if (tx.humanReadableType && tx.humanReadableType !== "Unknown Transaction") {
-    return tx.humanReadableType;
+  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 {
-  resolveTransactionSummary,
-  transactionSummaryRegistry
+  KeyType,
+  KeyTypeDetector,
+  detectKeyTypeFromString
 };
 //# sourceMappingURL=standards-sdk.es113.js.map