@hashgraphonline/standards-sdk 0.1.184 → 0.1.185

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

@@ -1,425 +1,238 @@
-import { HTSParser } from "./standards-sdk.es138.js";
-import { HCSParser } from "./standards-sdk.es169.js";
-import { CryptoParser } from "./standards-sdk.es171.js";
-import { FileParser } from "./standards-sdk.es170.js";
-import { SCSParser } from "./standards-sdk.es172.js";
-import { ScheduleParser } from "./standards-sdk.es139.js";
-import { UtilParser } from "./standards-sdk.es173.js";
-const transactionParserRegistry = {
-  TOKENCREATE: {
-    bodyField: "tokenCreation",
-    parser: HTSParser.parseTokenCreate,
-    resultField: "tokenCreation"
-  },
-  TOKENMINT: {
-    bodyField: "tokenMint",
-    parser: HTSParser.parseTokenMint,
-    resultField: "tokenMint"
-  },
-  TOKENBURN: {
-    bodyField: "tokenBurn",
-    parser: HTSParser.parseTokenBurn,
-    resultField: "tokenBurn"
-  },
-  TOKENUPDATE: {
-    bodyField: "tokenUpdate",
-    parser: HTSParser.parseTokenUpdate,
-    resultField: "tokenUpdate"
-  },
-  TOKENDELETE: {
-    bodyField: "tokenDeletion",
-    parser: HTSParser.parseTokenDelete,
-    resultField: "tokenDelete"
-  },
-  TOKENASSOCIATE: {
-    bodyField: "tokenAssociate",
-    parser: HTSParser.parseTokenAssociate,
-    resultField: "tokenAssociate"
-  },
-  TOKENDISSOCIATE: {
-    bodyField: "tokenDissociate",
-    parser: HTSParser.parseTokenDissociate,
-    resultField: "tokenDissociate"
-  },
-  TOKENFREEZE: {
-    bodyField: "tokenFreeze",
-    parser: HTSParser.parseTokenFreeze,
-    resultField: "tokenFreeze"
-  },
-  TOKENUNFREEZE: {
-    bodyField: "tokenUnfreeze",
-    parser: HTSParser.parseTokenUnfreeze,
-    resultField: "tokenUnfreeze"
-  },
-  TOKENGRANTKYC: {
-    bodyField: "tokenGrantKyc",
-    parser: HTSParser.parseTokenGrantKyc,
-    resultField: "tokenGrantKyc"
-  },
-  TOKENREVOKEKYC: {
-    bodyField: "tokenRevokeKyc",
-    parser: HTSParser.parseTokenRevokeKyc,
-    resultField: "tokenRevokeKyc"
-  },
-  TOKENPAUSE: {
-    bodyField: "tokenPause",
-    parser: HTSParser.parseTokenPause,
-    resultField: "tokenPause"
-  },
-  TOKENUNPAUSE: {
-    bodyField: "tokenUnpause",
-    parser: HTSParser.parseTokenUnpause,
-    resultField: "tokenUnpause"
-  },
-  TOKENWIPEACCOUNT: {
-    bodyField: "tokenWipe",
-    parser: HTSParser.parseTokenWipeAccount,
-    resultField: "tokenWipeAccount"
-  },
-  TOKENFEESCHEDULEUPDATE: {
-    bodyField: "tokenFeeScheduleUpdate",
-    parser: HTSParser.parseTokenFeeScheduleUpdate,
-    resultField: "tokenFeeScheduleUpdate"
-  },
-  TOKENAIRDROP: {
-    bodyField: "tokenAirdrop",
-    parser: HTSParser.parseTokenAirdropFromProto,
-    resultField: "tokenAirdrop"
-  },
-  TOPICCREATE: {
-    bodyField: "consensusCreateTopic",
-    parser: HCSParser.parseConsensusCreateTopic,
-    resultField: "consensusCreateTopic"
-  },
-  CONSENSUSSUBMITMESSAGE: {
-    bodyField: "consensusSubmitMessage",
-    parser: HCSParser.parseConsensusSubmitMessage,
-    resultField: "consensusSubmitMessage"
-  },
-  TOPICUPDATE: {
-    bodyField: "consensusUpdateTopic",
-    parser: HCSParser.parseConsensusUpdateTopic,
-    resultField: "consensusUpdateTopic"
-  },
-  TOPICDELETE: {
-    bodyField: "consensusDeleteTopic",
-    parser: HCSParser.parseConsensusDeleteTopic,
-    resultField: "consensusDeleteTopic"
-  },
-  ACCOUNTCREATE: {
-    bodyField: "cryptoCreateAccount",
-    parser: CryptoParser.parseCryptoCreateAccount,
-    resultField: "cryptoCreateAccount"
-  },
-  ACCOUNTUPDATE: {
-    bodyField: "cryptoUpdateAccount",
-    parser: CryptoParser.parseCryptoUpdateAccount,
-    resultField: "cryptoUpdateAccount"
-  },
-  ACCOUNTDELETE: {
-    bodyField: "cryptoDelete",
-    parser: CryptoParser.parseCryptoDelete,
-    resultField: "cryptoDelete"
-  },
-  CRYPTOTRANSFER: {
-    bodyField: "cryptoTransfer",
-    parser: (body) => {
-      const result = {
-        transfers: [],
-        tokenTransfers: []
-      };
-      CryptoParser.parseCryptoTransfers(body, result);
-      return result;
-    },
-    resultField: "transfers",
-    spreadResult: true
-  },
-  APPROVEALLOWANCE: {
-    bodyField: "cryptoApproveAllowance",
-    parser: CryptoParser.parseCryptoApproveAllowance,
-    resultField: "cryptoApproveAllowance"
-  },
-  DELETEALLOWANCE: {
-    bodyField: "cryptoDeleteAllowance",
-    parser: CryptoParser.parseCryptoDeleteAllowance,
-    resultField: "cryptoDeleteAllowance"
-  },
-  FILECREATE: {
-    bodyField: "fileCreate",
-    parser: FileParser.parseFileCreate,
-    resultField: "fileCreate"
-  },
-  FILEUPDATE: {
-    bodyField: "fileUpdate",
-    parser: FileParser.parseFileUpdate,
-    resultField: "fileUpdate"
-  },
-  FILEDELETE: {
-    bodyField: "fileDelete",
-    parser: FileParser.parseFileDelete,
-    resultField: "fileDelete"
-  },
-  FILEAPPEND: {
-    bodyField: "fileAppend",
-    parser: FileParser.parseFileAppend,
-    resultField: "fileAppend"
-  },
-  CONTRACTCREATE: {
-    bodyField: "contractCreateInstance",
-    parser: SCSParser.parseContractCreate,
-    resultField: "contractCreate"
-  },
-  CONTRACTUPDATE: {
-    bodyField: "contractUpdateInstance",
-    parser: SCSParser.parseContractUpdate,
-    resultField: "contractUpdate"
-  },
-  CONTRACTDELETE: {
-    bodyField: "contractDeleteInstance",
-    parser: SCSParser.parseContractDelete,
-    resultField: "contractDelete"
-  },
-  CONTRACTCALL: {
-    bodyField: "contractCall",
-    parser: SCSParser.parseContractCall,
-    resultField: "contractCall"
-  },
-  ETHEREUMTRANSACTION: {
-    bodyField: "ethereumTransaction",
-    parser: SCSParser.parseEthereumTransaction,
-    resultField: "ethereumTransaction"
-  },
-  SCHEDULECREATE: {
-    bodyField: "scheduleCreate",
-    parser: ScheduleParser.parseScheduleCreateFromProto,
-    resultField: "scheduleCreate"
-  },
-  SCHEDULESIGN: {
-    bodyField: "scheduleSign",
-    parser: ScheduleParser.parseScheduleSignFromProto,
-    resultField: "scheduleSign"
-  },
-  SCHEDULEDELETE: {
-    bodyField: "scheduleDelete",
-    parser: ScheduleParser.parseScheduleDeleteFromProto,
-    resultField: "scheduleDelete"
-  },
-  PRNG: {
-    bodyField: "utilPrng",
-    parser: UtilParser.parseUtilPrng,
-    resultField: "utilPrng"
-  },
-  FREEZE: {
-    bodyField: "freeze",
-    parser: UtilParser.parseFreeze,
-    resultField: "freeze"
-  },
-  SYSTEMDELETE: {
-    bodyField: "systemDelete",
-    parser: (body) => ({
-      fileId: body.fileID ? `${body.fileID.shardNum}.${body.fileID.realmNum}.${body.fileID.fileNum}` : void 0,
-      contractId: body.contractID ? `${body.contractID.shardNum}.${body.contractID.realmNum}.${body.contractID.contractNum}` : void 0,
-      expirationTime: body.expirationTime?.seconds ? body.expirationTime.seconds.toString() : void 0
-    }),
-    resultField: "systemDelete"
-  },
-  SYSTEMUNDELETE: {
-    bodyField: "systemUndelete",
-    parser: (body) => ({
-      fileId: body.fileID ? `${body.fileID.shardNum}.${body.fileID.realmNum}.${body.fileID.fileNum}` : void 0,
-      contractId: body.contractID ? `${body.contractID.shardNum}.${body.contractID.realmNum}.${body.contractID.contractNum}` : void 0
-    }),
-    resultField: "systemUndelete"
-  },
-  TOKENCANCELAIRDROP: {
-    bodyField: "tokenCancelAirdrop",
-    parser: (body) => ({
-      pendingAirdrops: body.pendingAirdrops || []
-    }),
-    resultField: "tokenCancelAirdrop"
-  },
-  TOKENCLAIMAIRDROP: {
-    bodyField: "tokenClaimAirdrop",
-    parser: (body) => ({
-      pendingAirdrops: body.pendingAirdrops || []
-    }),
-    resultField: "tokenClaimAirdrop"
-  },
-  TOKENREJECT: {
-    bodyField: "tokenReject",
-    parser: (body) => ({
-      owner: body.owner ? `${body.owner.shardNum}.${body.owner.realmNum}.${body.owner.accountNum}` : void 0,
-      rejections: body.rejections || []
-    }),
-    resultField: "tokenReject"
-  },
-  TOKENUPDATENFTS: {
-    bodyField: "tokenUpdateNfts",
-    parser: (body) => ({
-      tokenId: body.token ? `${body.token.shardNum}.${body.token.realmNum}.${body.token.tokenNum}` : void 0,
-      serialNumbers: body.serialNumbers || [],
-      metadata: body.metadata
-    }),
-    resultField: "tokenUpdateNfts"
-  },
-  TOKENWIPE: {
-    bodyField: "tokenWipe",
-    parser: HTSParser.parseTokenWipeAccount,
-    resultField: "tokenWipeAccount"
-  },
-  CRYPTOADDLIVEHASH: {
-    bodyField: "cryptoAddLiveHash",
-    parser: (body) => ({
-      accountId: body.accountID ? `${body.accountID.shardNum}.${body.accountID.realmNum}.${body.accountID.accountNum}` : void 0,
-      liveHash: body.liveHash
-    }),
-    resultField: "cryptoAddLiveHash"
-  },
-  CRYPTODELETELIVEHASH: {
-    bodyField: "cryptoDeleteLiveHash",
-    parser: (body) => ({
-      accountId: body.accountOfLiveHash ? `${body.accountOfLiveHash.shardNum}.${body.accountOfLiveHash.realmNum}.${body.accountOfLiveHash.accountNum}` : void 0,
-      liveHashToDelete: body.liveHashToDelete
-    }),
-    resultField: "cryptoDeleteLiveHash"
-  },
-  UNCHECKEDSUBMIT: {
-    bodyField: "uncheckedSubmit",
-    parser: (body) => ({
-      topicId: body.topicID ? `${body.topicID.shardNum}.${body.topicID.realmNum}.${body.topicID.topicNum}` : void 0,
-      message: body.message
-    }),
-    resultField: "uncheckedSubmit"
-  },
-  NODECREATE: {
-    bodyField: "nodeCreate",
-    parser: (body) => ({
-      accountId: body.accountId ? `${body.accountId.shardNum}.${body.accountId.realmNum}.${body.accountId.accountNum}` : void 0,
-      description: body.description,
-      gossipEndpoint: body.gossipEndpoint,
-      serviceEndpoint: body.serviceEndpoint,
-      gossipCaCertificate: body.gossipCaCertificate,
-      grpcCertificateHash: body.grpcCertificateHash,
-      adminKey: body.adminKey
-    }),
-    resultField: "nodeCreate"
-  },
-  NODEUPDATE: {
-    bodyField: "nodeUpdate",
-    parser: (body) => ({
-      nodeId: body.nodeId?.toString(),
-      accountId: body.accountId ? `${body.accountId.shardNum}.${body.accountId.realmNum}.${body.accountId.accountNum}` : void 0,
-      description: body.description,
-      gossipEndpoint: body.gossipEndpoint,
-      serviceEndpoint: body.serviceEndpoint,
-      gossipCaCertificate: body.gossipCaCertificate,
-      grpcCertificateHash: body.grpcCertificateHash,
-      adminKey: body.adminKey
-    }),
-    resultField: "nodeUpdate"
-  },
-  NODEDELETE: {
-    bodyField: "nodeDelete",
-    parser: (body) => ({
-      nodeId: body.nodeId?.toString()
-    }),
-    resultField: "nodeDelete"
-  },
-  NODESTAKEUPDATE: {
-    bodyField: "nodeStakeUpdate",
-    parser: (body) => ({
-      nodeId: body.nodeId?.toString(),
-      maxStake: body.maxStake?.toString(),
-      minStake: body.minStake?.toString(),
-      rewardRate: body.rewardRate?.toString()
-    }),
-    resultField: "nodeStakeUpdate"
-  },
-  ATOMICBATCH: {
-    bodyField: "atomicBatch",
-    parser: (body) => ({
-      transactions: body.transactions || []
-    }),
-    resultField: "atomicBatch"
-  },
-  STATESIGNATURETRANSACTION: {
-    bodyField: "stateSignatureTransaction",
-    parser: (body) => ({
-      signature: body.signature,
-      round: body.round?.toString()
-    }),
-    resultField: "stateSignatureTransaction"
-  },
-  HISTORYPROOFSIGNATURE: {
-    bodyField: "historyProofSignature",
-    parser: (body) => ({
-      signature: body.signature,
-      round: body.round?.toString()
-    }),
-    resultField: "historyProofSignature"
-  },
-  HISTORYPROOFKEYPUBLICATION: {
-    bodyField: "historyProofKeyPublication",
-    parser: (body) => ({
-      publicKey: body.publicKey,
-      round: body.round?.toString()
-    }),
-    resultField: "historyProofKeyPublication"
-  },
-  HISTORYPROOFVOTE: {
-    bodyField: "historyProofVote",
-    parser: (body) => ({
-      vote: body.vote,
-      round: body.round?.toString()
-    }),
-    resultField: "historyProofVote"
-  },
-  HINTSPREPROCESSINGVOTE: {
-    bodyField: "hintsPreprocessingVote",
-    parser: (body) => ({
-      vote: body.vote,
-      round: body.round?.toString()
-    }),
-    resultField: "hintsPreprocessingVote"
-  },
-  HINTSKEYPUBLICATION: {
-    bodyField: "hintsKeyPublication",
-    parser: (body) => ({
-      publicKey: body.publicKey,
-      round: body.round?.toString()
-    }),
-    resultField: "hintsKeyPublication"
-  },
-  HINTSPARTIALSIGNATURE: {
-    bodyField: "hintsPartialSignature",
-    parser: (body) => ({
-      signature: body.signature,
-      round: body.round?.toString()
-    }),
-    resultField: "hintsPartialSignature"
-  },
-  CRSPUBLICATION: {
-    bodyField: "crsPublication",
-    parser: (body) => ({
-      crs: body.crs,
-      round: body.round?.toString()
-    }),
-    resultField: "crsPublication"
+import { detectCryptoEnvironment } from "./standards-sdk.es138.js";
+import { FallbackHashAdapter, NodeHashAdapter, WebHashAdapter } from "./standards-sdk.es137.js";
+class NodeHmacAdapter {
+  constructor(nodeHmac) {
+    this.nodeHmac = nodeHmac;
+  }
+  update(data) {
+    this.nodeHmac.update(data);
+    return this;
+  }
+  digest(encoding) {
+    return this.nodeHmac.digest(encoding);
+  }
+}
+class WebHmacAdapter {
+  constructor(key, algorithm = "sha256") {
+    this.key = key;
+    this.algorithm = algorithm;
+    this.data = [];
+  }
+  update(data) {
+    this.data.push(data);
+    return this;
+  }
+  async digest(encoding) {
+    const combined = Buffer.concat(this.data);
+    const keyBytes = new Uint8Array(this.key);
+    const webCrypto = globalThis.crypto;
+    if (!webCrypto?.subtle) {
+      throw new Error("WebCrypto not available");
+    }
+    const keyBuffer = await webCrypto.subtle.importKey(
+      "raw",
+      keyBytes,
+      { name: "HMAC", hash: this.mapAlgorithm(this.algorithm) },
+      false,
+      ["sign"]
+    );
+    const signature = await webCrypto.subtle.sign(
+      "HMAC",
+      keyBuffer,
+      new Uint8Array(combined)
+    );
+    if (encoding === "hex") {
+      return Array.from(new Uint8Array(signature)).map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    return Buffer.from(signature);
+  }
+  mapAlgorithm(algorithm) {
+    const algorithmMap = {
+      sha256: "SHA-256",
+      sha1: "SHA-1",
+      sha512: "SHA-512"
+    };
+    return algorithmMap[algorithm.toLowerCase()] || "SHA-256";
+  }
+}
+class FallbackHmacAdapter {
+  constructor(key, algorithm = "sha256") {
+    this.key = key;
+    this.algorithm = algorithm;
+    this.data = [];
+  }
+  update(data) {
+    this.data.push(data);
+    return this;
+  }
+  digest(encoding) {
+    const combined = Buffer.concat(this.data);
+    const hash2 = this.simpleHmac(combined, this.key);
+    if (encoding === "hex") {
+      return hash2.toString(16).padStart(8, "0");
+    }
+    return hash2.toString();
+  }
+  simpleHmac(data, key) {
+    let hash2 = 0;
+    for (let i = 0; i < data.length; i++) {
+      const keyByte = key[i % key.length];
+      hash2 = (hash2 << 5) - hash2 + data[i] + keyByte & 4294967295;
+    }
+    return Math.abs(hash2);
+  }
+}
+class NodeCryptoAdapter {
+  constructor() {
+    try {
+      const moduleName = "crypto";
+      this.crypto = require(moduleName);
+    } catch (error) {
+      throw new Error("Node.js crypto module not available");
+    }
+  }
+  createHash(algorithm) {
+    return new NodeHashAdapter(this.crypto.createHash(algorithm));
+  }
+  createHmac(algorithm, key) {
+    return new NodeHmacAdapter(this.crypto.createHmac(algorithm, key));
+  }
+  async pbkdf2(password, salt, iterations, keylen, digest) {
+    return new Promise((resolve, reject) => {
+      this.crypto.pbkdf2(
+        password,
+        salt,
+        iterations,
+        keylen,
+        digest,
+        (err, derivedKey) => {
+          if (err) reject(err);
+          else resolve(derivedKey);
+        }
+      );
+    });
+  }
+  timingSafeEqual(a, b) {
+    return this.crypto.timingSafeEqual(a, b);
+  }
+}
+class WebCryptoAdapter {
+  createHash(algorithm) {
+    return new WebHashAdapter(algorithm);
+  }
+  createHmac(algorithm, key) {
+    return new WebHmacAdapter(key, algorithm);
+  }
+  async pbkdf2(password, salt, iterations, keylen, digest) {
+    const encoder = new TextEncoder();
+    const webCrypto = globalThis.crypto;
+    if (!webCrypto?.subtle) {
+      throw new Error("WebCrypto not available");
+    }
+    const keyMaterial = await webCrypto.subtle.importKey(
+      "raw",
+      encoder.encode(password),
+      { name: "PBKDF2" },
+      false,
+      ["deriveBits"]
+    );
+    const derivedBits = await webCrypto.subtle.deriveBits(
+      {
+        name: "PBKDF2",
+        salt: new Uint8Array(salt),
+        iterations,
+        hash: this.mapDigest(digest)
+      },
+      keyMaterial,
+      keylen * 8
+    );
+    return Buffer.from(derivedBits);
+  }
+  timingSafeEqual(a, b) {
+    if (a.length !== b.length) return false;
+    let result = 0;
+    for (let i = 0; i < a.length; i++) {
+      result |= a[i] ^ b[i];
+    }
+    return result === 0;
+  }
+  mapDigest(digest) {
+    const digestMap = {
+      sha256: "SHA-256",
+      sha1: "SHA-1",
+      sha512: "SHA-512"
+    };
+    return digestMap[digest.toLowerCase()] || "SHA-256";
+  }
+}
+class FallbackCryptoAdapter {
+  createHash(algorithm) {
+    return new FallbackHashAdapter(algorithm);
+  }
+  createHmac(algorithm, key) {
+    return new FallbackHmacAdapter(key, algorithm);
+  }
+  async pbkdf2(password, salt, iterations, keylen, digest) {
+    const encoder = new TextEncoder();
+    const passwordBuffer = Buffer.from(encoder.encode(password));
+    let result = Buffer.alloc(keylen);
+    for (let i = 0; i < iterations; i++) {
+      const combined = Buffer.concat([passwordBuffer, salt, Buffer.from([i])]);
+      let hash2 = 0;
+      for (let j = 0; j < combined.length; j++) {
+        hash2 = (hash2 << 5) - hash2 + combined[j] & 4294967295;
+      }
+      result[i % keylen] ^= hash2 & 255;
+    }
+    return result;
+  }
+  timingSafeEqual(a, b) {
+    if (a.length !== b.length) return false;
+    let result = 0;
+    for (let i = 0; i < a.length; i++) {
+      result |= a[i] ^ b[i];
+    }
+    return result === 0;
   }
-};
-function getParserConfig(transactionType) {
-  return transactionParserRegistry[transactionType];
 }
-function isTransactionTypeSupported(transactionType) {
-  return transactionType in transactionParserRegistry;
+function getCryptoAdapter() {
+  const env = detectCryptoEnvironment();
+  switch (env.preferredAPI) {
+    case "node":
+      try {
+        return new NodeCryptoAdapter();
+      } catch {
+        const globalCrypto = typeof globalThis !== "undefined" ? globalThis.crypto : void 0;
+        if (typeof globalCrypto?.subtle !== "undefined") {
+          return new WebCryptoAdapter();
+        }
+        return new FallbackCryptoAdapter();
+      }
+    case "web":
+      return new WebCryptoAdapter();
+    case "none":
+    default:
+      return new FallbackCryptoAdapter();
+  }
 }
-function getSupportedTransactionTypes() {
-  return Object.keys(transactionParserRegistry);
+async function hash(content, algorithm = "sha256") {
+  const adapter = getCryptoAdapter();
+  const hasher = adapter.createHash(algorithm);
+  const buffer = typeof content === "string" ? Buffer.from(content) : content;
+  const result = hasher.update(buffer).digest("hex");
+  if (result instanceof Promise) {
+    return await result;
+  }
+  return result;
 }
 export {
-  getParserConfig,
-  getSupportedTransactionTypes,
-  isTransactionTypeSupported,
-  transactionParserRegistry
+  FallbackCryptoAdapter,
+  FallbackHmacAdapter,
+  NodeCryptoAdapter,
+  NodeHmacAdapter,
+  WebCryptoAdapter,
+  WebHmacAdapter,
+  getCryptoAdapter,
+  hash
 };
 //# sourceMappingURL=standards-sdk.es140.js.map