@hashgraphonline/standards-sdk 0.1.170 → 0.1.172

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

@@ -1,175 +1,79 @@
-import * as path from "path";
+import { proto } from "@hashgraph/proto";
+import { ContractId } from "@hashgraph/sdk";
 import { Buffer } from "buffer";
-import { randomBytes } from "crypto";
-import { secp256k1 } from "@noble/curves/secp256k1.js";
-import { registerEncryptionKeyResponseSchema } from "./standards-sdk.es145.js";
-import { optionalImport } from "./standards-sdk.es162.js";
-const getFs = async () => {
-  const fsModule = await optionalImport("node:fs");
-  if (fsModule && typeof fsModule.existsSync === "function" && typeof fsModule.readFileSync === "function" && typeof fsModule.writeFileSync === "function" && typeof fsModule.appendFileSync === "function") {
-    return fsModule;
+function parseKey(key) {
+  if (!key) {
+    return void 0;
   }
-  return null;
-};
-async function registerEncryptionKey(client, payload) {
-  const raw = await client.requestJson("/encryption/keys", {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: payload
-  });
-  return client.parseWithSchema(
-    raw,
-    registerEncryptionKeyResponseSchema,
-    "register encryption key response"
-  );
-}
-function normalizeAutoRegisterIdentity(config) {
-  const identity = {};
-  if (config.uaid) {
-    identity.uaid = config.uaid;
-  }
-  if (config.ledgerAccountId) {
-    identity.ledgerAccountId = config.ledgerAccountId;
-    if (config.ledgerNetwork) {
-      identity.ledgerNetwork = config.ledgerNetwork;
-    }
+  if (key.contractID) {
+    return `ContractID: ${new ContractId(
+      key.contractID.shardNum ?? 0,
+      key.contractID.realmNum ?? 0,
+      key.contractID.contractNum ?? 0
+    ).toString()}`;
   }
-  if (config.email) {
-    identity.email = config.email;
+  if (key.ed25519) {
+    return `ED25519: ${Buffer.from(key.ed25519).toString("hex")}`;
   }
-  if (identity.uaid || identity.ledgerAccountId || identity.email) {
-    return identity;
+  if (key.ECDSASecp256k1) {
+    return `ECDSA_secp256k1: ${Buffer.from(key.ECDSASecp256k1).toString(
+      "hex"
+    )}`;
   }
-  return null;
-}
-function derivePublicKeyFromPrivateKey(client, privateKey) {
-  const normalized = client.hexToBuffer(privateKey);
-  const publicKey = secp256k1.getPublicKey(normalized, true);
-  return Buffer.from(publicKey).toString("hex");
-}
-async function resolveAutoRegisterKeyMaterial(client, config) {
-  if (config.publicKey?.trim()) {
-    return { publicKey: config.publicKey.trim() };
+  if (key?.keyList?.keys?.length > 0) {
+    const keys = key.keyList.keys.map((k) => parseKey(k)).filter(Boolean);
+    return `KeyList (${keys.length} keys): [${keys.join(", ")}]`;
   }
-  let privateKey = config.privateKey?.trim();
-  const envVar = config.envVar ?? "RB_ENCRYPTION_PRIVATE_KEY";
-  if (!privateKey && envVar && process?.env?.[envVar]?.trim()) {
-    privateKey = process.env[envVar]?.trim();
+  if (key?.thresholdKey?.keys?.keys?.length > 0) {
+    const keys = key.thresholdKey.keys.keys.map((k) => parseKey(k)).filter(Boolean);
+    return `ThresholdKey (${key.thresholdKey.threshold} of ${keys.length}): [${keys.join(", ")}]`;
   }
-  if (!privateKey && config.generateIfMissing) {
-    const pair = await client.generateEncryptionKeyPair({
-      keyType: config.keyType ?? "secp256k1",
-      envVar,
-      envPath: config.envPath,
-      overwrite: config.overwriteEnv
-    });
-    return { publicKey: pair.publicKey, privateKey: pair.privateKey };
+  if (key.delegatableContractId) {
+    return `DelegatableContractID: ${new ContractId(
+      key.delegatableContractId.shardNum ?? 0,
+      key.delegatableContractId.realmNum ?? 0,
+      key.delegatableContractId.contractNum ?? 0
+    ).toString()}`;
   }
-  if (privateKey) {
-    const publicKey = derivePublicKeyFromPrivateKey(client, privateKey);
-    return { publicKey, privateKey };
-  }
-  return null;
-}
-async function autoRegisterEncryptionKey(client, config) {
-  const identity = normalizeAutoRegisterIdentity(config);
-  if (!identity) {
-    throw new Error(
-      "Auto-registration requires uaid, ledgerAccountId, or email"
-    );
-  }
-  const material = await resolveAutoRegisterKeyMaterial(client, config);
-  if (!material) {
-    throw new Error(
-      "Unable to resolve encryption public key for auto-registration"
-    );
-  }
-  await registerEncryptionKey(client, {
-    keyType: config.keyType ?? "secp256k1",
-    publicKey: material.publicKey,
-    ...identity
-  });
-  return material;
-}
-async function ensureAgentEncryptionKey(client, options) {
-  return autoRegisterEncryptionKey(client, {
-    ...options,
-    uaid: options.uaid
-  });
-}
-function createEncryptionApi(client) {
-  return {
-    registerKey: (payload) => registerEncryptionKey(client, payload),
-    generateEphemeralKeyPair: () => client.createEphemeralKeyPair(),
-    deriveSharedSecret: (options) => client.deriveSharedSecret(options),
-    encryptCipherEnvelope: (options) => client.buildCipherEnvelope(options),
-    decryptCipherEnvelope: (options) => client.openCipherEnvelope(options),
-    ensureAgentKey: (options) => ensureAgentEncryptionKey(client, options)
-  };
-}
-async function bootstrapEncryptionOptions(client, options) {
-  if (!options?.autoRegister || options.autoRegister.enabled === false) {
-    return null;
+  if (Object.keys(key).length === 0) {
+    return "Empty Key Structure";
   }
-  return autoRegisterEncryptionKey(client, options.autoRegister);
+  return "Unknown or Unset Key Type";
 }
-async function generateEncryptionKeyPair(client, options = {}) {
-  client.assertNodeRuntime("generateEncryptionKeyPair");
-  const keyType = options.keyType ?? "secp256k1";
-  if (keyType !== "secp256k1") {
-    throw new Error("Only secp256k1 key generation is supported currently");
-  }
-  const privateKeyBytes = randomBytes(32);
-  const privateKey = Buffer.from(privateKeyBytes).toString("hex");
-  const publicKeyBytes = secp256k1.getPublicKey(privateKeyBytes, true);
-  const publicKey = Buffer.from(publicKeyBytes).toString("hex");
-  const envVar = options.envVar ?? "RB_ENCRYPTION_PRIVATE_KEY";
-  const resolvedPath = options.envPath ? path.resolve(options.envPath) : void 0;
-  if (resolvedPath) {
-    const fsModule = await getFs();
-    if (!fsModule) {
-      throw new Error(
-        "File system module is not available; cannot write encryption key env file"
-      );
+function extractTransactionBody(transaction) {
+  try {
+    const bytes = transaction.toBytes ? transaction.toBytes() : void 0;
+    if (!bytes) {
+      return null;
+    }
+    const decoded = proto.TransactionList.decode(bytes);
+    if (!decoded.transactionList || decoded.transactionList.length === 0) {
+      return null;
     }
-    const envLine = `${envVar}=${privateKey}`;
-    if (fsModule.existsSync(resolvedPath)) {
-      const content = fsModule.readFileSync(resolvedPath, "utf-8");
-      const lineRegex = new RegExp(`^${envVar}=.*$`, "m");
-      if (lineRegex.test(content)) {
-        if (!options.overwrite) {
-          throw new Error(
-            `${envVar} already exists in ${resolvedPath}; set overwrite=true to replace it`
-          );
-        }
-        const updated = content.replace(lineRegex, envLine);
-        fsModule.writeFileSync(resolvedPath, updated);
-      } else {
-        const needsNewline = !content.endsWith("\n");
-        fsModule.appendFileSync(
-          resolvedPath,
-          `${needsNewline ? "\n" : ""}${envLine}
-`
-        );
+    const tx = decoded.transactionList[0];
+    if (tx.bodyBytes && tx.bodyBytes.length > 0) {
+      return proto.TransactionBody.decode(tx.bodyBytes);
+    }
+    if (tx.signedTransactionBytes && tx.signedTransactionBytes.length > 0) {
+      const signedTx = proto.SignedTransaction.decode(
+        tx.signedTransactionBytes
+      );
+      if (signedTx.bodyBytes) {
+        return proto.TransactionBody.decode(signedTx.bodyBytes);
       }
-    } else {
-      fsModule.writeFileSync(resolvedPath, `${envLine}
-`);
     }
+    return null;
+  } catch (error) {
+    return null;
   }
-  return {
-    privateKey,
-    publicKey,
-    envPath: resolvedPath,
-    envVar
-  };
+}
+function hasTransactionType(transaction, transactionField) {
+  const txBody = extractTransactionBody(transaction);
+  return !!(txBody && txBody[transactionField]);
 }
 export {
-  autoRegisterEncryptionKey,
-  bootstrapEncryptionOptions,
-  createEncryptionApi,
-  ensureAgentEncryptionKey,
-  generateEncryptionKeyPair,
-  registerEncryptionKey
+  extractTransactionBody,
+  hasTransactionType,
+  parseKey
 };
 //# sourceMappingURL=standards-sdk.es174.js.map

package/dist/es/standards-sdk.es174.js.map

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es174.js","sources":["../../src/services/registry-broker/client/encryption.ts"],"sourcesContent":["import * as path from 'path';\nimport { Buffer } from 'buffer';\nimport { randomBytes } from 'crypto';\nimport { secp256k1 } from '@noble/curves/secp256k1.js';\nimport type {\n  AutoRegisterEncryptionKeyOptions,\n  CipherEnvelope,\n  ClientEncryptionOptions,\n  DecryptCipherEnvelopeOptions,\n  DeriveSharedSecretOptions,\n  EncryptCipherEnvelopeOptions,\n  EphemeralKeyPair,\n  EnsureAgentKeyOptions,\n  RegisterEncryptionKeyPayload,\n  RegisterEncryptionKeyResponse,\n  SharedSecretInput,\n} from '../types';\nimport { registerEncryptionKeyResponseSchema } from '../schemas';\nimport { optionalImport } from '../../../utils/dynamic-import';\nimport type {\n  RegistryBrokerClient,\n  GenerateEncryptionKeyPairOptions,\n} from './base-client';\n\ntype FsModule = {\n  existsSync: (path: string) => boolean;\n  readFileSync: (path: string, encoding: BufferEncoding) => string;\n  writeFileSync: (path: string, data: string) => void;\n  appendFileSync: (path: string, data: string) => void;\n};\n\nconst getFs = async (): Promise<FsModule | null> => {\n  const fsModule = await optionalImport<Partial<FsModule>>('node:fs');\n\n  if (\n    fsModule &&\n    typeof fsModule.existsSync === 'function' &&\n    typeof fsModule.readFileSync === 'function' &&\n    typeof fsModule.writeFileSync === 'function' &&\n    typeof fsModule.appendFileSync === 'function'\n  ) {\n    return fsModule as FsModule;\n  }\n\n  return null;\n};\n\nexport interface RegistryBrokerEncryptionApi {\n  registerKey: (\n    payload: RegisterEncryptionKeyPayload,\n  ) => Promise<RegisterEncryptionKeyResponse>;\n  generateEphemeralKeyPair: () => EphemeralKeyPair;\n  deriveSharedSecret: (options: DeriveSharedSecretOptions) => Buffer;\n  encryptCipherEnvelope: (\n    options: EncryptCipherEnvelopeOptions,\n  ) => CipherEnvelope;\n  decryptCipherEnvelope: (options: DecryptCipherEnvelopeOptions) => string;\n  ensureAgentKey: (\n    options: EnsureAgentKeyOptions,\n  ) => Promise<{ publicKey: string; privateKey?: string }>;\n}\n\nexport async function registerEncryptionKey(\n  client: RegistryBrokerClient,\n  payload: RegisterEncryptionKeyPayload,\n): Promise<RegisterEncryptionKeyResponse> {\n  const raw = await client.requestJson('/encryption/keys', {\n    method: 'POST',\n    headers: { 'content-type': 'application/json' },\n    body: payload,\n  });\n  return client.parseWithSchema(\n    raw,\n    registerEncryptionKeyResponseSchema,\n    'register encryption key response',\n  );\n}\n\nfunction normalizeAutoRegisterIdentity(\n  config: AutoRegisterEncryptionKeyOptions,\n): Pick<\n  RegisterEncryptionKeyPayload,\n  'uaid' | 'ledgerAccountId' | 'ledgerNetwork' | 'email'\n> | null {\n  const identity: Pick<\n    RegisterEncryptionKeyPayload,\n    'uaid' | 'ledgerAccountId' | 'ledgerNetwork' | 'email'\n  > = {};\n  if (config.uaid) {\n    identity.uaid = config.uaid;\n  }\n  if (config.ledgerAccountId) {\n    identity.ledgerAccountId = config.ledgerAccountId;\n    if (config.ledgerNetwork) {\n      identity.ledgerNetwork = config.ledgerNetwork;\n    }\n  }\n  if (config.email) {\n    identity.email = config.email;\n  }\n  if (identity.uaid || identity.ledgerAccountId || identity.email) {\n    return identity;\n  }\n  return null;\n}\n\nfunction derivePublicKeyFromPrivateKey(\n  client: RegistryBrokerClient,\n  privateKey: string,\n): string {\n  const normalized = client.hexToBuffer(privateKey);\n  const publicKey = secp256k1.getPublicKey(normalized, true);\n  return Buffer.from(publicKey).toString('hex');\n}\n\nasync function resolveAutoRegisterKeyMaterial(\n  client: RegistryBrokerClient,\n  config: AutoRegisterEncryptionKeyOptions,\n): Promise<{ publicKey: string; privateKey?: string } | null> {\n  if (config.publicKey?.trim()) {\n    return { publicKey: config.publicKey.trim() };\n  }\n  let privateKey = config.privateKey?.trim();\n  const envVar = config.envVar ?? 'RB_ENCRYPTION_PRIVATE_KEY';\n  if (!privateKey && envVar && process?.env?.[envVar]?.trim()) {\n    privateKey = process.env[envVar]?.trim();\n  }\n  if (!privateKey && config.generateIfMissing) {\n    const pair = await client.generateEncryptionKeyPair({\n      keyType: config.keyType ?? 'secp256k1',\n      envVar,\n      envPath: config.envPath,\n      overwrite: config.overwriteEnv,\n    });\n    return { publicKey: pair.publicKey, privateKey: pair.privateKey };\n  }\n  if (privateKey) {\n    const publicKey = derivePublicKeyFromPrivateKey(client, privateKey);\n    return { publicKey, privateKey };\n  }\n  return null;\n}\n\nexport async function autoRegisterEncryptionKey(\n  client: RegistryBrokerClient,\n  config: AutoRegisterEncryptionKeyOptions,\n): Promise<{ publicKey: string; privateKey?: string }> {\n  const identity = normalizeAutoRegisterIdentity(config);\n  if (!identity) {\n    throw new Error(\n      'Auto-registration requires uaid, ledgerAccountId, or email',\n    );\n  }\n  const material = await resolveAutoRegisterKeyMaterial(client, config);\n  if (!material) {\n    throw new Error(\n      'Unable to resolve encryption public key for auto-registration',\n    );\n  }\n  await registerEncryptionKey(client, {\n    keyType: config.keyType ?? 'secp256k1',\n    publicKey: material.publicKey,\n    ...identity,\n  });\n  return material;\n}\n\nexport async function ensureAgentEncryptionKey(\n  client: RegistryBrokerClient,\n  options: EnsureAgentKeyOptions,\n): Promise<{ publicKey: string; privateKey?: string }> {\n  return autoRegisterEncryptionKey(client, {\n    ...options,\n    uaid: options.uaid,\n    enabled: true,\n  });\n}\n\nexport function createEncryptionApi(\n  client: RegistryBrokerClient,\n): RegistryBrokerEncryptionApi {\n  return {\n    registerKey: (payload: RegisterEncryptionKeyPayload) =>\n      registerEncryptionKey(client, payload),\n    generateEphemeralKeyPair: () => client.createEphemeralKeyPair(),\n    deriveSharedSecret: (options: DeriveSharedSecretOptions) =>\n      client.deriveSharedSecret(options),\n    encryptCipherEnvelope: (options: EncryptCipherEnvelopeOptions) =>\n      client.buildCipherEnvelope(options),\n    decryptCipherEnvelope: (options: DecryptCipherEnvelopeOptions) =>\n      client.openCipherEnvelope(options),\n    ensureAgentKey: (options: EnsureAgentKeyOptions) =>\n      ensureAgentEncryptionKey(client, options),\n  };\n}\n\nexport async function bootstrapEncryptionOptions(\n  client: RegistryBrokerClient,\n  options?: ClientEncryptionOptions,\n): Promise<{ publicKey: string; privateKey?: string } | null> {\n  if (!options?.autoRegister || options.autoRegister.enabled === false) {\n    return null;\n  }\n  return autoRegisterEncryptionKey(client, options.autoRegister);\n}\n\nexport async function generateEncryptionKeyPair(\n  client: RegistryBrokerClient,\n  options: GenerateEncryptionKeyPairOptions = {},\n): Promise<{\n  privateKey: string;\n  publicKey: string;\n  envPath?: string;\n  envVar: string;\n}> {\n  client.assertNodeRuntime('generateEncryptionKeyPair');\n\n  const keyType = options.keyType ?? 'secp256k1';\n  if (keyType !== 'secp256k1') {\n    throw new Error('Only secp256k1 key generation is supported currently');\n  }\n\n  const privateKeyBytes = randomBytes(32);\n  const privateKey = Buffer.from(privateKeyBytes).toString('hex');\n  const publicKeyBytes = secp256k1.getPublicKey(privateKeyBytes, true);\n  const publicKey = Buffer.from(publicKeyBytes).toString('hex');\n\n  const envVar = options.envVar ?? 'RB_ENCRYPTION_PRIVATE_KEY';\n  const resolvedPath = options.envPath\n    ? path.resolve(options.envPath)\n    : undefined;\n\n  if (resolvedPath) {\n    const fsModule = await getFs();\n\n    if (!fsModule) {\n      throw new Error(\n        'File system module is not available; cannot write encryption key env file',\n      );\n    }\n\n    const envLine = `${envVar}=${privateKey}`;\n    if (fsModule.existsSync(resolvedPath)) {\n      const content = fsModule.readFileSync(resolvedPath, 'utf-8');\n      const lineRegex = new RegExp(`^${envVar}=.*$`, 'm');\n      if (lineRegex.test(content)) {\n        if (!options.overwrite) {\n          throw new Error(\n            `${envVar} already exists in ${resolvedPath}; set overwrite=true to replace it`,\n          );\n        }\n        const updated = content.replace(lineRegex, envLine);\n        fsModule.writeFileSync(resolvedPath, updated);\n      } else {\n        const needsNewline = !content.endsWith('\\n');\n        fsModule.appendFileSync(\n          resolvedPath,\n          `${needsNewline ? '\\n' : ''}${envLine}\\n`,\n        );\n      }\n    } else {\n      fsModule.writeFileSync(resolvedPath, `${envLine}\\n`);\n    }\n  }\n\n  return {\n    privateKey,\n    publicKey,\n    envPath: resolvedPath,\n    envVar,\n  };\n}\n"],"names":[],"mappings":";;;;;;AA+BA,MAAM,QAAQ,YAAsC;AAClD,QAAM,WAAW,MAAM,eAAkC,SAAS;AAElE,MACE,YACA,OAAO,SAAS,eAAe,cAC/B,OAAO,SAAS,iBAAiB,cACjC,OAAO,SAAS,kBAAkB,cAClC,OAAO,SAAS,mBAAmB,YACnC;AACA,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAiBA,eAAsB,sBACpB,QACA,SACwC;AACxC,QAAM,MAAM,MAAM,OAAO,YAAY,oBAAoB;AAAA,IACvD,QAAQ;AAAA,IACR,SAAS,EAAE,gBAAgB,mBAAA;AAAA,IAC3B,MAAM;AAAA,EAAA,CACP;AACD,SAAO,OAAO;AAAA,IACZ;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAEJ;AAEA,SAAS,8BACP,QAIO;AACP,QAAM,WAGF,CAAA;AACJ,MAAI,OAAO,MAAM;AACf,aAAS,OAAO,OAAO;AAAA,EACzB;AACA,MAAI,OAAO,iBAAiB;AAC1B,aAAS,kBAAkB,OAAO;AAClC,QAAI,OAAO,eAAe;AACxB,eAAS,gBAAgB,OAAO;AAAA,IAClC;AAAA,EACF;AACA,MAAI,OAAO,OAAO;AAChB,aAAS,QAAQ,OAAO;AAAA,EAC1B;AACA,MAAI,SAAS,QAAQ,SAAS,mBAAmB,SAAS,OAAO;AAC/D,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAEA,SAAS,8BACP,QACA,YACQ;AACR,QAAM,aAAa,OAAO,YAAY,UAAU;AAChD,QAAM,YAAY,UAAU,aAAa,YAAY,IAAI;AACzD,SAAO,OAAO,KAAK,SAAS,EAAE,SAAS,KAAK;AAC9C;AAEA,eAAe,+BACb,QACA,QAC4D;AAC5D,MAAI,OAAO,WAAW,QAAQ;AAC5B,WAAO,EAAE,WAAW,OAAO,UAAU,OAAK;AAAA,EAC5C;AACA,MAAI,aAAa,OAAO,YAAY,KAAA;AACpC,QAAM,SAAS,OAAO,UAAU;AAChC,MAAI,CAAC,cAAc,UAAU,SAAS,MAAM,MAAM,GAAG,QAAQ;AAC3D,iBAAa,QAAQ,IAAI,MAAM,GAAG,KAAA;AAAA,EACpC;AACA,MAAI,CAAC,cAAc,OAAO,mBAAmB;AAC3C,UAAM,OAAO,MAAM,OAAO,0BAA0B;AAAA,MAClD,SAAS,OAAO,WAAW;AAAA,MAC3B;AAAA,MACA,SAAS,OAAO;AAAA,MAChB,WAAW,OAAO;AAAA,IAAA,CACnB;AACD,WAAO,EAAE,WAAW,KAAK,WAAW,YAAY,KAAK,WAAA;AAAA,EACvD;AACA,MAAI,YAAY;AACd,UAAM,YAAY,8BAA8B,QAAQ,UAAU;AAClE,WAAO,EAAE,WAAW,WAAA;AAAA,EACtB;AACA,SAAO;AACT;AAEA,eAAsB,0BACpB,QACA,QACqD;AACrD,QAAM,WAAW,8BAA8B,MAAM;AACrD,MAAI,CAAC,UAAU;AACb,UAAM,IAAI;AAAA,MACR;AAAA,IAAA;AAAA,EAEJ;AACA,QAAM,WAAW,MAAM,+BAA+B,QAAQ,MAAM;AACpE,MAAI,CAAC,UAAU;AACb,UAAM,IAAI;AAAA,MACR;AAAA,IAAA;AAAA,EAEJ;AACA,QAAM,sBAAsB,QAAQ;AAAA,IAClC,SAAS,OAAO,WAAW;AAAA,IAC3B,WAAW,SAAS;AAAA,IACpB,GAAG;AAAA,EAAA,CACJ;AACD,SAAO;AACT;AAEA,eAAsB,yBACpB,QACA,SACqD;AACrD,SAAO,0BAA0B,QAAQ;AAAA,IACvC,GAAG;AAAA,IACH,MAAM,QAAQ;AAAA,EAEhB,CAAC;AACH;AAEO,SAAS,oBACd,QAC6B;AAC7B,SAAO;AAAA,IACL,aAAa,CAAC,YACZ,sBAAsB,QAAQ,OAAO;AAAA,IACvC,0BAA0B,MAAM,OAAO,uBAAA;AAAA,IACvC,oBAAoB,CAAC,YACnB,OAAO,mBAAmB,OAAO;AAAA,IACnC,uBAAuB,CAAC,YACtB,OAAO,oBAAoB,OAAO;AAAA,IACpC,uBAAuB,CAAC,YACtB,OAAO,mBAAmB,OAAO;AAAA,IACnC,gBAAgB,CAAC,YACf,yBAAyB,QAAQ,OAAO;AAAA,EAAA;AAE9C;AAEA,eAAsB,2BACpB,QACA,SAC4D;AAC5D,MAAI,CAAC,SAAS,gBAAgB,QAAQ,aAAa,YAAY,OAAO;AACpE,WAAO;AAAA,EACT;AACA,SAAO,0BAA0B,QAAQ,QAAQ,YAAY;AAC/D;AAEA,eAAsB,0BACpB,QACA,UAA4C,IAM3C;AACD,SAAO,kBAAkB,2BAA2B;AAEpD,QAAM,UAAU,QAAQ,WAAW;AACnC,MAAI,YAAY,aAAa;AAC3B,UAAM,IAAI,MAAM,sDAAsD;AAAA,EACxE;AAEA,QAAM,kBAAkB,YAAY,EAAE;AACtC,QAAM,aAAa,OAAO,KAAK,eAAe,EAAE,SAAS,KAAK;AAC9D,QAAM,iBAAiB,UAAU,aAAa,iBAAiB,IAAI;AACnE,QAAM,YAAY,OAAO,KAAK,cAAc,EAAE,SAAS,KAAK;AAE5D,QAAM,SAAS,QAAQ,UAAU;AACjC,QAAM,eAAe,QAAQ,UACzB,KAAK,QAAQ,QAAQ,OAAO,IAC5B;AAEJ,MAAI,cAAc;AAChB,UAAM,WAAW,MAAM,MAAA;AAEvB,QAAI,CAAC,UAAU;AACb,YAAM,IAAI;AAAA,QACR;AAAA,MAAA;AAAA,IAEJ;AAEA,UAAM,UAAU,GAAG,MAAM,IAAI,UAAU;AACvC,QAAI,SAAS,WAAW,YAAY,GAAG;AACrC,YAAM,UAAU,SAAS,aAAa,cAAc,OAAO;AAC3D,YAAM,YAAY,IAAI,OAAO,IAAI,MAAM,QAAQ,GAAG;AAClD,UAAI,UAAU,KAAK,OAAO,GAAG;AAC3B,YAAI,CAAC,QAAQ,WAAW;AACtB,gBAAM,IAAI;AAAA,YACR,GAAG,MAAM,sBAAsB,YAAY;AAAA,UAAA;AAAA,QAE/C;AACA,cAAM,UAAU,QAAQ,QAAQ,WAAW,OAAO;AAClD,iBAAS,cAAc,cAAc,OAAO;AAAA,MAC9C,OAAO;AACL,cAAM,eAAe,CAAC,QAAQ,SAAS,IAAI;AAC3C,iBAAS;AAAA,UACP;AAAA,UACA,GAAG,eAAe,OAAO,EAAE,GAAG,OAAO;AAAA;AAAA,QAAA;AAAA,MAEzC;AAAA,IACF,OAAO;AACL,eAAS,cAAc,cAAc,GAAG,OAAO;AAAA,CAAI;AAAA,IACrD;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,SAAS;AAAA,IACT;AAAA,EAAA;AAEJ;"}
+{"version":3,"file":"standards-sdk.es174.js","sources":["../../src/utils/parsers/parser-utils.ts"],"sourcesContent":["import { proto } from '@hashgraph/proto';\nimport { ContractId, Transaction } from '@hashgraph/sdk';\nimport { Buffer } from 'buffer';\n\nexport function parseKey(\n  key: proto.IKey | null | undefined,\n): string | undefined {\n  if (!key) {\n    return undefined;\n  }\n\n  if (key.contractID) {\n    return `ContractID: ${new ContractId(\n      key.contractID.shardNum ?? 0,\n      key.contractID.realmNum ?? 0,\n      key.contractID.contractNum ?? 0,\n    ).toString()}`;\n  }\n  if (key.ed25519) {\n    return `ED25519: ${Buffer.from(key.ed25519).toString('hex')}`;\n  }\n  if (key.ECDSASecp256k1) {\n    return `ECDSA_secp256k1: ${Buffer.from(key.ECDSASecp256k1).toString(\n      'hex',\n    )}`;\n  }\n  if (key?.keyList?.keys?.length > 0) {\n    const keys = key.keyList.keys.map(k => parseKey(k)).filter(Boolean);\n    return `KeyList (${keys.length} keys): [${keys.join(', ')}]`;\n  }\n  if (key?.thresholdKey?.keys?.keys?.length > 0) {\n    const keys = key.thresholdKey.keys.keys\n      .map(k => parseKey(k))\n      .filter(Boolean);\n    return `ThresholdKey (${key.thresholdKey.threshold} of ${\n      keys.length\n    }): [${keys.join(', ')}]`;\n  }\n  if (key.delegatableContractId) {\n    return `DelegatableContractID: ${new ContractId(\n      key.delegatableContractId.shardNum ?? 0,\n      key.delegatableContractId.realmNum ?? 0,\n      key.delegatableContractId.contractNum ?? 0,\n    ).toString()}`;\n  }\n  if (Object.keys(key).length === 0) {\n    return 'Empty Key Structure';\n  }\n\n  return 'Unknown or Unset Key Type';\n}\n\n/**\n * Extract TransactionBody from Transaction object using protobuf parsing\n * This replaces fragile constructor name checking with reliable protobuf data\n */\nexport function extractTransactionBody(\n  transaction: Transaction,\n): proto.ITransactionBody | null {\n  try {\n    const bytes = transaction.toBytes ? transaction.toBytes() : undefined;\n    if (!bytes) {\n      return null;\n    }\n\n    const decoded = proto.TransactionList.decode(bytes);\n    if (!decoded.transactionList || decoded.transactionList.length === 0) {\n      return null;\n    }\n\n    const tx = decoded.transactionList[0];\n\n    if (tx.bodyBytes && tx.bodyBytes.length > 0) {\n      return proto.TransactionBody.decode(tx.bodyBytes);\n    }\n\n    if (tx.signedTransactionBytes && tx.signedTransactionBytes.length > 0) {\n      const signedTx = proto.SignedTransaction.decode(\n        tx.signedTransactionBytes,\n      );\n      if (signedTx.bodyBytes) {\n        return proto.TransactionBody.decode(signedTx.bodyBytes);\n      }\n    }\n\n    return null;\n  } catch (error) {\n    return null;\n  }\n}\n\n/**\n * Check if transaction has specific transaction type using protobuf data\n * This replaces constructor name checking with reliable protobuf field detection\n */\nexport function hasTransactionType(\n  transaction: Transaction,\n  transactionField: keyof proto.ITransactionBody,\n): boolean {\n  const txBody = extractTransactionBody(transaction);\n  return !!(txBody && txBody[transactionField]);\n}\n"],"names":[],"mappings":";;;AAIO,SAAS,SACd,KACoB;AACpB,MAAI,CAAC,KAAK;AACR,WAAO;AAAA,EACT;AAEA,MAAI,IAAI,YAAY;AAClB,WAAO,eAAe,IAAI;AAAA,MACxB,IAAI,WAAW,YAAY;AAAA,MAC3B,IAAI,WAAW,YAAY;AAAA,MAC3B,IAAI,WAAW,eAAe;AAAA,IAAA,EAC9B,UAAU;AAAA,EACd;AACA,MAAI,IAAI,SAAS;AACf,WAAO,YAAY,OAAO,KAAK,IAAI,OAAO,EAAE,SAAS,KAAK,CAAC;AAAA,EAC7D;AACA,MAAI,IAAI,gBAAgB;AACtB,WAAO,oBAAoB,OAAO,KAAK,IAAI,cAAc,EAAE;AAAA,MACzD;AAAA,IAAA,CACD;AAAA,EACH;AACA,MAAI,KAAK,SAAS,MAAM,SAAS,GAAG;AAClC,UAAM,OAAO,IAAI,QAAQ,KAAK,IAAI,CAAA,MAAK,SAAS,CAAC,CAAC,EAAE,OAAO,OAAO;AAClE,WAAO,YAAY,KAAK,MAAM,YAAY,KAAK,KAAK,IAAI,CAAC;AAAA,EAC3D;AACA,MAAI,KAAK,cAAc,MAAM,MAAM,SAAS,GAAG;AAC7C,UAAM,OAAO,IAAI,aAAa,KAAK,KAChC,IAAI,CAAA,MAAK,SAAS,CAAC,CAAC,EACpB,OAAO,OAAO;AACjB,WAAO,iBAAiB,IAAI,aAAa,SAAS,OAChD,KAAK,MACP,OAAO,KAAK,KAAK,IAAI,CAAC;AAAA,EACxB;AACA,MAAI,IAAI,uBAAuB;AAC7B,WAAO,0BAA0B,IAAI;AAAA,MACnC,IAAI,sBAAsB,YAAY;AAAA,MACtC,IAAI,sBAAsB,YAAY;AAAA,MACtC,IAAI,sBAAsB,eAAe;AAAA,IAAA,EACzC,UAAU;AAAA,EACd;AACA,MAAI,OAAO,KAAK,GAAG,EAAE,WAAW,GAAG;AACjC,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAMO,SAAS,uBACd,aAC+B;AAC/B,MAAI;AACF,UAAM,QAAQ,YAAY,UAAU,YAAY,YAAY;AAC5D,QAAI,CAAC,OAAO;AACV,aAAO;AAAA,IACT;AAEA,UAAM,UAAU,MAAM,gBAAgB,OAAO,KAAK;AAClD,QAAI,CAAC,QAAQ,mBAAmB,QAAQ,gBAAgB,WAAW,GAAG;AACpE,aAAO;AAAA,IACT;AAEA,UAAM,KAAK,QAAQ,gBAAgB,CAAC;AAEpC,QAAI,GAAG,aAAa,GAAG,UAAU,SAAS,GAAG;AAC3C,aAAO,MAAM,gBAAgB,OAAO,GAAG,SAAS;AAAA,IAClD;AAEA,QAAI,GAAG,0BAA0B,GAAG,uBAAuB,SAAS,GAAG;AACrE,YAAM,WAAW,MAAM,kBAAkB;AAAA,QACvC,GAAG;AAAA,MAAA;AAEL,UAAI,SAAS,WAAW;AACtB,eAAO,MAAM,gBAAgB,OAAO,SAAS,SAAS;AAAA,MACxD;AAAA,IACF;AAEA,WAAO;AAAA,EACT,SAAS,OAAO;AACd,WAAO;AAAA,EACT;AACF;AAMO,SAAS,mBACd,aACA,kBACS;AACT,QAAM,SAAS,uBAAuB,WAAW;AACjD,SAAO,CAAC,EAAE,UAAU,OAAO,gBAAgB;AAC7C;"}

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

@@ -1,225 +1,175 @@
-import { searchResponseSchema, statsResponseSchema, registriesResponseSchema, additionalRegistryCatalogResponseSchema, popularResponseSchema, protocolsResponseSchema, detectProtocolResponseSchema, registrySearchByNamespaceSchema, vectorSearchResponseSchema, searchStatusResponseSchema, websocketStatsResponseSchema, metricsSummaryResponseSchema, searchFacetsResponseSchema } from "./standards-sdk.es145.js";
-import { buildSearchQuery } from "./standards-sdk.es176.js";
-import { RegistryBrokerError } from "./standards-sdk.es146.js";
-function buildVectorFallbackSearchParams(request) {
-  const params = {
-    q: request.query
-  };
-  let effectiveLimit;
-  if (typeof request.limit === "number" && Number.isFinite(request.limit)) {
-    effectiveLimit = request.limit;
-    params.limit = request.limit;
-  }
-  if (typeof request.offset === "number" && Number.isFinite(request.offset) && request.offset > 0) {
-    const limit = effectiveLimit && effectiveLimit > 0 ? effectiveLimit : 20;
-    params.limit = limit;
-    params.page = Math.floor(request.offset / limit) + 1;
-  }
-  if (request.filter?.registry) {
-    params.registry = request.filter.registry;
-  }
-  if (request.filter?.protocols?.length) {
-    params.protocols = [...request.filter.protocols];
-  }
-  if (request.filter?.adapter?.length) {
-    params.adapters = [...request.filter.adapter];
+import * as path from "path";
+import { Buffer } from "buffer";
+import { randomBytes } from "crypto";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { registerEncryptionKeyResponseSchema } from "./standards-sdk.es145.js";
+import { optionalImport } from "./standards-sdk.es163.js";
+const getFs = async () => {
+  const fsModule = await optionalImport("node:fs");
+  if (fsModule && typeof fsModule.existsSync === "function" && typeof fsModule.readFileSync === "function" && typeof fsModule.writeFileSync === "function" && typeof fsModule.appendFileSync === "function") {
+    return fsModule;
   }
-  if (request.filter?.capabilities?.length) {
-    params.capabilities = request.filter.capabilities.map(
-      (value) => typeof value === "number" ? value.toString(10) : value
-    );
-  }
-  if (request.filter?.type) {
-    params.type = request.filter.type;
-  }
-  return params;
-}
-function convertSearchResultToVectorResponse(result) {
-  const hits = result.hits.map((agent) => ({
-    agent,
-    score: 0,
-    highlights: {}
-  }));
-  const total = result.total;
-  const limit = result.limit;
-  const page = result.page;
-  const totalVisible = page * limit;
-  const limited = total > totalVisible || page > 1;
-  return {
-    hits,
-    total,
-    took: 0,
-    totalAvailable: total,
-    visible: hits.length,
-    limited,
-    credits_used: 0
-  };
-}
-async function search(client, params = {}) {
-  const query = buildSearchQuery(params);
-  const raw = await client.requestJson(`/search${query}`, {
-    method: "GET"
-  });
-  return client.parseWithSchema(raw, searchResponseSchema, "search response");
-}
-async function stats(client) {
-  const raw = await client.requestJson("/stats", { method: "GET" });
-  return client.parseWithSchema(raw, statsResponseSchema, "stats response");
-}
-async function registries(client) {
-  const raw = await client.requestJson("/registries", {
-    method: "GET"
-  });
-  return client.parseWithSchema(
-    raw,
-    registriesResponseSchema,
-    "registries response"
-  );
-}
-async function getAdditionalRegistries(client) {
-  const raw = await client.requestJson(
-    "/register/additional-registries",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    additionalRegistryCatalogResponseSchema,
-    "additional registry catalog response"
-  );
-}
-async function popularSearches(client) {
-  const raw = await client.requestJson("/popular", {
-    method: "GET"
-  });
-  return client.parseWithSchema(
-    raw,
-    popularResponseSchema,
-    "popular searches response"
-  );
-}
-async function listProtocols(client) {
-  const raw = await client.requestJson("/protocols", {
-    method: "GET"
-  });
-  return client.parseWithSchema(
-    raw,
-    protocolsResponseSchema,
-    "protocols response"
-  );
-}
-async function detectProtocol(client, message) {
-  const raw = await client.requestJson("/detect-protocol", {
+  return null;
+};
+async function registerEncryptionKey(client, payload) {
+  const raw = await client.requestJson("/encryption/keys", {
     method: "POST",
-    body: { message },
-    headers: { "content-type": "application/json" }
+    headers: { "content-type": "application/json" },
+    body: payload
   });
   return client.parseWithSchema(
     raw,
-    detectProtocolResponseSchema,
-    "detect protocol response"
+    registerEncryptionKeyResponseSchema,
+    "register encryption key response"
   );
 }
-async function registrySearchByNamespace(client, registry, query) {
-  const params = new URLSearchParams();
-  if (query) {
-    params.set("q", query);
+function normalizeAutoRegisterIdentity(config) {
+  const identity = {};
+  if (config.uaid) {
+    identity.uaid = config.uaid;
   }
-  const suffix = params.size > 0 ? `?${params.toString()}` : "";
-  const raw = await client.requestJson(
-    `/registries/${encodeURIComponent(registry)}/search${suffix}`,
-    {
-      method: "GET"
+  if (config.ledgerAccountId) {
+    identity.ledgerAccountId = config.ledgerAccountId;
+    if (config.ledgerNetwork) {
+      identity.ledgerNetwork = config.ledgerNetwork;
     }
-  );
-  return client.parseWithSchema(
-    raw,
-    registrySearchByNamespaceSchema,
-    "registry search response"
-  );
+  }
+  if (config.email) {
+    identity.email = config.email;
+  }
+  if (identity.uaid || identity.ledgerAccountId || identity.email) {
+    return identity;
+  }
+  return null;
+}
+function derivePublicKeyFromPrivateKey(client, privateKey) {
+  const normalized = client.hexToBuffer(privateKey);
+  const publicKey = secp256k1.getPublicKey(normalized, true);
+  return Buffer.from(publicKey).toString("hex");
 }
-async function vectorSearch(client, request) {
-  try {
-    const raw = await client.requestJson("/search", {
-      method: "POST",
-      body: request,
-      headers: { "content-type": "application/json" }
+async function resolveAutoRegisterKeyMaterial(client, config) {
+  if (config.publicKey?.trim()) {
+    return { publicKey: config.publicKey.trim() };
+  }
+  let privateKey = config.privateKey?.trim();
+  const envVar = config.envVar ?? "RB_ENCRYPTION_PRIVATE_KEY";
+  if (!privateKey && envVar && process?.env?.[envVar]?.trim()) {
+    privateKey = process.env[envVar]?.trim();
+  }
+  if (!privateKey && config.generateIfMissing) {
+    const pair = await client.generateEncryptionKeyPair({
+      keyType: config.keyType ?? "secp256k1",
+      envVar,
+      envPath: config.envPath,
+      overwrite: config.overwriteEnv
     });
-    return client.parseWithSchema(
-      raw,
-      vectorSearchResponseSchema,
-      "vector search response"
-    );
-  } catch (error) {
-    if (error instanceof RegistryBrokerError && error.status === 501) {
-      const fallback = await search(
-        client,
-        buildVectorFallbackSearchParams(request)
-      );
-      return convertSearchResultToVectorResponse(fallback);
-    }
-    throw error;
+    return { publicKey: pair.publicKey, privateKey: pair.privateKey };
   }
+  if (privateKey) {
+    const publicKey = derivePublicKeyFromPrivateKey(client, privateKey);
+    return { publicKey, privateKey };
+  }
+  return null;
 }
-async function searchStatus(client) {
-  const raw = await client.requestJson("/search/status", {
-    method: "GET"
+async function autoRegisterEncryptionKey(client, config) {
+  const identity = normalizeAutoRegisterIdentity(config);
+  if (!identity) {
+    throw new Error(
+      "Auto-registration requires uaid, ledgerAccountId, or email"
+    );
+  }
+  const material = await resolveAutoRegisterKeyMaterial(client, config);
+  if (!material) {
+    throw new Error(
+      "Unable to resolve encryption public key for auto-registration"
+    );
+  }
+  await registerEncryptionKey(client, {
+    keyType: config.keyType ?? "secp256k1",
+    publicKey: material.publicKey,
+    ...identity
   });
-  return client.parseWithSchema(
-    raw,
-    searchStatusResponseSchema,
-    "search status response"
-  );
+  return material;
 }
-async function websocketStats(client) {
-  const raw = await client.requestJson("/websocket/stats", {
-    method: "GET"
+async function ensureAgentEncryptionKey(client, options) {
+  return autoRegisterEncryptionKey(client, {
+    ...options,
+    uaid: options.uaid
   });
-  return client.parseWithSchema(
-    raw,
-    websocketStatsResponseSchema,
-    "websocket stats response"
-  );
 }
-async function metricsSummary(client) {
-  const raw = await client.requestJson("/metrics", {
-    method: "GET"
-  });
-  return client.parseWithSchema(
-    raw,
-    metricsSummaryResponseSchema,
-    "metrics summary response"
-  );
+function createEncryptionApi(client) {
+  return {
+    registerKey: (payload) => registerEncryptionKey(client, payload),
+    generateEphemeralKeyPair: () => client.createEphemeralKeyPair(),
+    deriveSharedSecret: (options) => client.deriveSharedSecret(options),
+    encryptCipherEnvelope: (options) => client.buildCipherEnvelope(options),
+    decryptCipherEnvelope: (options) => client.openCipherEnvelope(options),
+    ensureAgentKey: (options) => ensureAgentEncryptionKey(client, options)
+  };
 }
-async function facets(client, adapter) {
-  const params = new URLSearchParams();
-  if (adapter) {
-    params.set("adapter", adapter);
+async function bootstrapEncryptionOptions(client, options) {
+  if (!options?.autoRegister || options.autoRegister.enabled === false) {
+    return null;
   }
-  const suffix = params.size > 0 ? `?${params.toString()}` : "";
-  const raw = await client.requestJson(`/search/facets${suffix}`, {
-    method: "GET"
-  });
-  return client.parseWithSchema(
-    raw,
-    searchFacetsResponseSchema,
-    "search facets response"
-  );
+  return autoRegisterEncryptionKey(client, options.autoRegister);
+}
+async function generateEncryptionKeyPair(client, options = {}) {
+  client.assertNodeRuntime("generateEncryptionKeyPair");
+  const keyType = options.keyType ?? "secp256k1";
+  if (keyType !== "secp256k1") {
+    throw new Error("Only secp256k1 key generation is supported currently");
+  }
+  const privateKeyBytes = randomBytes(32);
+  const privateKey = Buffer.from(privateKeyBytes).toString("hex");
+  const publicKeyBytes = secp256k1.getPublicKey(privateKeyBytes, true);
+  const publicKey = Buffer.from(publicKeyBytes).toString("hex");
+  const envVar = options.envVar ?? "RB_ENCRYPTION_PRIVATE_KEY";
+  const resolvedPath = options.envPath ? path.resolve(options.envPath) : void 0;
+  if (resolvedPath) {
+    const fsModule = await getFs();
+    if (!fsModule) {
+      throw new Error(
+        "File system module is not available; cannot write encryption key env file"
+      );
+    }
+    const envLine = `${envVar}=${privateKey}`;
+    if (fsModule.existsSync(resolvedPath)) {
+      const content = fsModule.readFileSync(resolvedPath, "utf-8");
+      const lineRegex = new RegExp(`^${envVar}=.*$`, "m");
+      if (lineRegex.test(content)) {
+        if (!options.overwrite) {
+          throw new Error(
+            `${envVar} already exists in ${resolvedPath}; set overwrite=true to replace it`
+          );
+        }
+        const updated = content.replace(lineRegex, envLine);
+        fsModule.writeFileSync(resolvedPath, updated);
+      } else {
+        const needsNewline = !content.endsWith("\n");
+        fsModule.appendFileSync(
+          resolvedPath,
+          `${needsNewline ? "\n" : ""}${envLine}
+`
+        );
+      }
+    } else {
+      fsModule.writeFileSync(resolvedPath, `${envLine}
+`);
+    }
+  }
+  return {
+    privateKey,
+    publicKey,
+    envPath: resolvedPath,
+    envVar
+  };
 }
 export {
-  detectProtocol,
-  facets,
-  getAdditionalRegistries,
-  listProtocols,
-  metricsSummary,
-  popularSearches,
-  registries,
-  registrySearchByNamespace,
-  search,
-  searchStatus,
-  stats,
-  vectorSearch,
-  websocketStats
+  autoRegisterEncryptionKey,
+  bootstrapEncryptionOptions,
+  createEncryptionApi,
+  ensureAgentEncryptionKey,
+  generateEncryptionKeyPair,
+  registerEncryptionKey
 };
 //# sourceMappingURL=standards-sdk.es175.js.map