@hashgraphonline/standards-sdk 0.1.183 → 0.1.185

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

@@ -1,211 +1,425 @@
-import { InscriptionSDK } from "./standards-sdk.es162.js";
-class QuoteCache {
-  constructor() {
-    this.cache = /* @__PURE__ */ new Map();
-    this.maxSize = 100;
-    this.defaultTtlMs = 5 * 60 * 1e3;
+import { HTSParser } from "./standards-sdk.es141.js";
+import { HCSParser } from "./standards-sdk.es173.js";
+import { CryptoParser } from "./standards-sdk.es175.js";
+import { FileParser } from "./standards-sdk.es174.js";
+import { SCSParser } from "./standards-sdk.es176.js";
+import { ScheduleParser } from "./standards-sdk.es142.js";
+import { UtilParser } from "./standards-sdk.es177.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"
   }
-  // 5 minutes
-  /**
-   * Generate cache key from input parameters
-   */
-  generateKey(key) {
-    return `${key.inputHash}-${key.clientConfigHash}-${key.optionsHash}`;
-  }
-  /**
-   * Hash object to string for cache key
-   */
-  hashObject(obj) {
-    return Buffer.from(JSON.stringify(obj)).toString("base64").slice(0, 16);
-  }
-  /**
-   * Create cache key from parameters
-   */
-  createCacheKey(input, clientConfig, options) {
-    return {
-      inputHash: this.hashObject(input),
-      clientConfigHash: this.hashObject({
-        accountId: clientConfig.accountId,
-        network: clientConfig.network
-      }),
-      optionsHash: this.hashObject({
-        mode: options.mode,
-        apiKey: options.apiKey ? "present" : "absent",
-        network: options.network,
-        metadata: options.metadata
-      })
-    };
-  }
-  /**
-   * Get cached quote if available and not expired
-   */
-  get(key) {
-    const cacheKey = this.generateKey(key);
-    const entry = this.cache.get(cacheKey);
-    if (!entry) {
-      return null;
-    }
-    const now = Date.now();
-    if (now - entry.timestamp > entry.ttlMs) {
-      this.cache.delete(cacheKey);
-      return null;
-    }
-    this.cache.delete(cacheKey);
-    this.cache.set(cacheKey, entry);
-    return entry.quote;
-  }
-  /**
-   * Store quote in cache
-   */
-  set(key, quote, ttlMs = this.defaultTtlMs) {
-    const cacheKey = this.generateKey(key);
-    if (this.cache.size >= this.maxSize) {
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey) {
-        this.cache.delete(firstKey);
-      }
-    }
-    this.cache.set(cacheKey, {
-      quote,
-      timestamp: Date.now(),
-      ttlMs
-    });
-  }
-  /**
-   * Clear all cached entries
-   */
-  clear() {
-    this.cache.clear();
-  }
-}
-class SDKCache {
-  constructor() {
-    this.cache = /* @__PURE__ */ new Map();
-    this.maxSize = 10;
-    this.defaultTtlMs = 30 * 60 * 1e3;
-  }
-  // 30 minutes
-  /**
-   * Generate config key for SDK instance
-   */
-  generateConfigKey(config) {
-    return Buffer.from(JSON.stringify(config)).toString("base64");
-  }
-  /**
-   * Get cached SDK instance
-   */
-  get(config) {
-    const configKey = this.generateConfigKey(config);
-    const entry = this.cache.get(configKey);
-    if (!entry) {
-      return null;
-    }
-    const now = Date.now();
-    if (now - entry.timestamp > this.defaultTtlMs) {
-      this.cache.delete(configKey);
-      return null;
-    }
-    return entry.sdk;
-  }
-  /**
-   * Store SDK instance in cache
-   */
-  set(config, sdk) {
-    const configKey = this.generateConfigKey(config);
-    if (this.cache.size >= this.maxSize) {
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey) {
-        this.cache.delete(firstKey);
-      }
-    }
-    this.cache.set(configKey, {
-      sdk,
-      timestamp: Date.now(),
-      config: configKey
-    });
-  }
-  /**
-   * Clear all cached SDK instances
-   */
-  clear() {
-    this.cache.clear();
-  }
-}
-const quoteCache = new QuoteCache();
-const sdkCache = new SDKCache();
-async function getOrCreateSDK(clientConfig, options, existingSDK) {
-  if (existingSDK) {
-    return existingSDK;
-  }
-  const connectionMode = options.connectionMode ?? "websocket";
-  const cacheConfig = {
-    apiKey: options.apiKey,
-    accountId: clientConfig.accountId,
-    network: clientConfig.network || "mainnet",
-    authType: options.apiKey ? "api" : "server",
-    connectionMode
-  };
-  const cachedSDK = sdkCache.get(cacheConfig);
-  if (cachedSDK) {
-    return cachedSDK;
-  }
-  let sdk;
-  if (options.apiKey) {
-    sdk = new InscriptionSDK({
-      apiKey: options.apiKey,
-      network: clientConfig.network || "mainnet",
-      connectionMode
-    });
-  } else {
-    sdk = await InscriptionSDK.createWithAuth({
-      type: "server",
-      accountId: clientConfig.accountId,
-      privateKey: typeof clientConfig.privateKey === "string" ? clientConfig.privateKey : clientConfig.privateKey.toString(),
-      network: clientConfig.network || "mainnet",
-      connectionMode
-    });
-  }
-  sdkCache.set(cacheConfig, sdk);
-  return sdk;
-}
-function getCachedQuote(input, clientConfig, options) {
-  const cacheKey = quoteCache.createCacheKey(input, clientConfig, options);
-  return quoteCache.get(cacheKey);
+};
+function getParserConfig(transactionType) {
+  return transactionParserRegistry[transactionType];
 }
-function cacheQuote(input, clientConfig, options, quote) {
-  const cacheKey = quoteCache.createCacheKey(input, clientConfig, options);
-  const quoteTtlMs = 10 * 60 * 1e3;
-  quoteCache.set(cacheKey, quote, quoteTtlMs);
+function isTransactionTypeSupported(transactionType) {
+  return transactionType in transactionParserRegistry;
 }
-function validateQuoteParameters(input, clientConfig, options) {
-  if (!input || typeof input !== "object" || !("type" in input)) {
-    throw new Error("Invalid inscription input: type is required");
-  }
-  if (!clientConfig || !clientConfig.accountId) {
-    throw new Error("Invalid client config: accountId is required");
-  }
-  if (!options) {
-    throw new Error("Options are required");
-  }
-  if (options.mode === "hashinal") {
-    if (!options.metadata) {
-      throw new Error("Hashinal mode requires metadata");
-    }
-    const requiredFields = ["name", "creator", "description", "type"];
-    const missingFields = requiredFields.filter(
-      (field) => !options.metadata || !options.metadata[field]
-    );
-    if (missingFields.length > 0) {
-      throw new Error(
-        `Missing required Hashinal metadata fields: ${missingFields.join(", ")}`
-      );
-    }
-  }
+function getSupportedTransactionTypes() {
+  return Object.keys(transactionParserRegistry);
 }
 export {
-  cacheQuote,
-  getCachedQuote,
-  getOrCreateSDK,
-  validateQuoteParameters
+  getParserConfig,
+  getSupportedTransactionTypes,
+  isTransactionTypeSupported,
+  transactionParserRegistry
 };
 //# sourceMappingURL=standards-sdk.es143.js.map